actions_gen.go

// Code generated by octo-go; DO NOT EDIT.

package actions

import (
	"context"
	"fmt"
	components "github.com/willabides/octo-go/components"
	internal "github.com/willabides/octo-go/internal"
	requests "github.com/willabides/octo-go/requests"
	"net/http"
	"net/url"
	"strconv"
)

// Client is a set of options to apply to requests
type Client []requests.Option

// NewClient returns a new Client
func NewClient(opt ...requests.Option) Client {
	return opt
}

/*
AddSelectedRepoToOrgSecret performs requests for "actions/add-selected-repo-to-org-secret"

Add selected repository to an organization secret.

  PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}

https://developer.github.com/v3/actions/secrets/#add-selected-repository-to-an-organization-secret
*/
func AddSelectedRepoToOrgSecret(ctx context.Context, req *AddSelectedRepoToOrgSecretReq, opt ...requests.Option) (*AddSelectedRepoToOrgSecretResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(AddSelectedRepoToOrgSecretReq)
	}
	resp := &AddSelectedRepoToOrgSecretResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
AddSelectedRepoToOrgSecret performs requests for "actions/add-selected-repo-to-org-secret"

Add selected repository to an organization secret.

  PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}

https://developer.github.com/v3/actions/secrets/#add-selected-repository-to-an-organization-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) AddSelectedRepoToOrgSecret(ctx context.Context, req *AddSelectedRepoToOrgSecretReq, opt ...requests.Option) (*AddSelectedRepoToOrgSecretResponse, error) {
	return AddSelectedRepoToOrgSecret(ctx, req, append(c, opt...)...)
}

/*
AddSelectedRepoToOrgSecretReq is request data for Client.AddSelectedRepoToOrgSecret

https://developer.github.com/v3/actions/secrets/#add-selected-repository-to-an-organization-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type AddSelectedRepoToOrgSecretReq struct {
	_url string
	Org  string

	// secret_name parameter
	SecretName string

	// repository_id parameter
	RepositoryId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *AddSelectedRepoToOrgSecretReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		Method:      "PUT",
		Options:     opt,
		URLPath:     fmt.Sprintf("/orgs/%v/actions/secrets/%v/repositories/%v", r.Org, r.SecretName, r.RepositoryId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *AddSelectedRepoToOrgSecretReq) Rel(link string, resp *AddSelectedRepoToOrgSecretResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
AddSelectedRepoToOrgSecretResponse is a response for AddSelectedRepoToOrgSecret

https://developer.github.com/v3/actions/secrets/#add-selected-repository-to-an-organization-secret
*/
type AddSelectedRepoToOrgSecretResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *AddSelectedRepoToOrgSecretResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *AddSelectedRepoToOrgSecretResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{204})
	if err != nil {
		return err
	}
	return nil
}

/*
CancelWorkflowRun performs requests for "actions/cancel-workflow-run"

Cancel a workflow run.

  POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel

https://developer.github.com/v3/actions/workflow-runs/#cancel-a-workflow-run
*/
func CancelWorkflowRun(ctx context.Context, req *CancelWorkflowRunReq, opt ...requests.Option) (*CancelWorkflowRunResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(CancelWorkflowRunReq)
	}
	resp := &CancelWorkflowRunResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
CancelWorkflowRun performs requests for "actions/cancel-workflow-run"

Cancel a workflow run.

  POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel

https://developer.github.com/v3/actions/workflow-runs/#cancel-a-workflow-run

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) CancelWorkflowRun(ctx context.Context, req *CancelWorkflowRunReq, opt ...requests.Option) (*CancelWorkflowRunResponse, error) {
	return CancelWorkflowRun(ctx, req, append(c, opt...)...)
}

/*
CancelWorkflowRunReq is request data for Client.CancelWorkflowRun

https://developer.github.com/v3/actions/workflow-runs/#cancel-a-workflow-run

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type CancelWorkflowRunReq struct {
	_url  string
	Owner string
	Repo  string
	RunId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *CancelWorkflowRunReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		Method:      "POST",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/runs/%v/cancel", r.Owner, r.Repo, r.RunId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *CancelWorkflowRunReq) Rel(link string, resp *CancelWorkflowRunResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
CancelWorkflowRunResponse is a response for CancelWorkflowRun

https://developer.github.com/v3/actions/workflow-runs/#cancel-a-workflow-run
*/
type CancelWorkflowRunResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *CancelWorkflowRunResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *CancelWorkflowRunResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{202})
	if err != nil {
		return err
	}
	return nil
}

/*
CreateOrUpdateOrgSecret performs requests for "actions/create-or-update-org-secret"

Create or update an organization secret.

  PUT /orgs/{org}/actions/secrets/{secret_name}

https://developer.github.com/v3/actions/secrets/#create-or-update-an-organization-secret
*/
func CreateOrUpdateOrgSecret(ctx context.Context, req *CreateOrUpdateOrgSecretReq, opt ...requests.Option) (*CreateOrUpdateOrgSecretResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(CreateOrUpdateOrgSecretReq)
	}
	resp := &CreateOrUpdateOrgSecretResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
CreateOrUpdateOrgSecret performs requests for "actions/create-or-update-org-secret"

Create or update an organization secret.

  PUT /orgs/{org}/actions/secrets/{secret_name}

https://developer.github.com/v3/actions/secrets/#create-or-update-an-organization-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) CreateOrUpdateOrgSecret(ctx context.Context, req *CreateOrUpdateOrgSecretReq, opt ...requests.Option) (*CreateOrUpdateOrgSecretResponse, error) {
	return CreateOrUpdateOrgSecret(ctx, req, append(c, opt...)...)
}

/*
CreateOrUpdateOrgSecretReq is request data for Client.CreateOrUpdateOrgSecret

https://developer.github.com/v3/actions/secrets/#create-or-update-an-organization-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type CreateOrUpdateOrgSecretReq struct {
	_url string
	Org  string

	// secret_name parameter
	SecretName  string
	RequestBody CreateOrUpdateOrgSecretReqBody
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *CreateOrUpdateOrgSecretReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		Body:        r.RequestBody,
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"content-type": internal.String("application/json")},
		Method:      "PUT",
		Options:     opt,
		URLPath:     fmt.Sprintf("/orgs/%v/actions/secrets/%v", r.Org, r.SecretName),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *CreateOrUpdateOrgSecretReq) Rel(link string, resp *CreateOrUpdateOrgSecretResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
CreateOrUpdateOrgSecretReqBody is a request body for actions/create-or-update-org-secret

https://developer.github.com/v3/actions/secrets/#create-or-update-an-organization-secret
*/
type CreateOrUpdateOrgSecretReqBody struct {

	/*
	Value for your secret, encrypted with
	[LibSodium](https://libsodium.gitbook.io/doc/bindings_for_other_languages) using
	the public key retrieved from the [Get an organization public
	key](https://developer.github.com/v3/actions/secrets/#get-an-organization-public-key)
	endpoint.
	*/
	EncryptedValue *string `json:"encrypted_value,omitempty"`

	// ID of the key you used to encrypt the secret.
	KeyId *string `json:"key_id,omitempty"`

	/*
	An array of repository ids that can access the organization secret. You can only
	provide a list of repository ids when the `visibility` is set to `selected`. You
	can manage the list of selected repositories using the [List selected
	repositories for an organization
	secret](https://developer.github.com/v3/actions/secrets/#list-selected-repositories-for-an-organization-secret),
	[Set selected repositories for an organization
	secret](https://developer.github.com/v3/actions/secrets/#set-selected-repositories-for-an-organization-secret),
	and [Remove selected repository from an organization
	secret](https://developer.github.com/v3/actions/secrets/#remove-selected-repository-from-an-organization-secret)
	endpoints.
	*/
	SelectedRepositoryIds []string `json:"selected_repository_ids,omitempty"`

	/*
	Configures the access that repositories have to the organization secret. Can be
	one of:
	\- `all` - All repositories in an organization can access the secret.
	\- `private` - Private repositories in an organization can access the secret.
	\- `selected` - Only specific repositories can access the secret.
	*/
	Visibility *string `json:"visibility,omitempty"`
}

/*
CreateOrUpdateOrgSecretResponse is a response for CreateOrUpdateOrgSecret

https://developer.github.com/v3/actions/secrets/#create-or-update-an-organization-secret
*/
type CreateOrUpdateOrgSecretResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *CreateOrUpdateOrgSecretResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *CreateOrUpdateOrgSecretResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{201, 204})
	if err != nil {
		return err
	}
	return nil
}

/*
CreateOrUpdateRepoSecret performs requests for "actions/create-or-update-repo-secret"

Create or update a repository secret.

  PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}

https://developer.github.com/v3/actions/secrets/#create-or-update-a-repository-secret
*/
func CreateOrUpdateRepoSecret(ctx context.Context, req *CreateOrUpdateRepoSecretReq, opt ...requests.Option) (*CreateOrUpdateRepoSecretResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(CreateOrUpdateRepoSecretReq)
	}
	resp := &CreateOrUpdateRepoSecretResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
CreateOrUpdateRepoSecret performs requests for "actions/create-or-update-repo-secret"

Create or update a repository secret.

  PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}

https://developer.github.com/v3/actions/secrets/#create-or-update-a-repository-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) CreateOrUpdateRepoSecret(ctx context.Context, req *CreateOrUpdateRepoSecretReq, opt ...requests.Option) (*CreateOrUpdateRepoSecretResponse, error) {
	return CreateOrUpdateRepoSecret(ctx, req, append(c, opt...)...)
}

/*
CreateOrUpdateRepoSecretReq is request data for Client.CreateOrUpdateRepoSecret

https://developer.github.com/v3/actions/secrets/#create-or-update-a-repository-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type CreateOrUpdateRepoSecretReq struct {
	_url  string
	Owner string
	Repo  string

	// secret_name parameter
	SecretName  string
	RequestBody CreateOrUpdateRepoSecretReqBody
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *CreateOrUpdateRepoSecretReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		Body:        r.RequestBody,
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"content-type": internal.String("application/json")},
		Method:      "PUT",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/secrets/%v", r.Owner, r.Repo, r.SecretName),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *CreateOrUpdateRepoSecretReq) Rel(link string, resp *CreateOrUpdateRepoSecretResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
CreateOrUpdateRepoSecretReqBody is a request body for actions/create-or-update-repo-secret

https://developer.github.com/v3/actions/secrets/#create-or-update-a-repository-secret
*/
type CreateOrUpdateRepoSecretReqBody struct {

	/*
	Value for your secret, encrypted with
	[LibSodium](https://libsodium.gitbook.io/doc/bindings_for_other_languages) using
	the public key retrieved from the [Get a repository public
	key](https://developer.github.com/v3/actions/secrets/#get-a-repository-public-key)
	endpoint.
	*/
	EncryptedValue *string `json:"encrypted_value,omitempty"`

	// ID of the key you used to encrypt the secret.
	KeyId *string `json:"key_id,omitempty"`
}

/*
CreateOrUpdateRepoSecretResponse is a response for CreateOrUpdateRepoSecret

https://developer.github.com/v3/actions/secrets/#create-or-update-a-repository-secret
*/
type CreateOrUpdateRepoSecretResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *CreateOrUpdateRepoSecretResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *CreateOrUpdateRepoSecretResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{201, 204})
	if err != nil {
		return err
	}
	return nil
}

/*
CreateRegistrationTokenForOrg performs requests for "actions/create-registration-token-for-org"

Create a registration token for an organization.

  POST /orgs/{org}/actions/runners/registration-token

https://developer.github.com/v3/actions/self-hosted-runners/#create-a-registration-token-for-an-organization
*/
func CreateRegistrationTokenForOrg(ctx context.Context, req *CreateRegistrationTokenForOrgReq, opt ...requests.Option) (*CreateRegistrationTokenForOrgResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(CreateRegistrationTokenForOrgReq)
	}
	resp := &CreateRegistrationTokenForOrgResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
CreateRegistrationTokenForOrg performs requests for "actions/create-registration-token-for-org"

Create a registration token for an organization.

  POST /orgs/{org}/actions/runners/registration-token

https://developer.github.com/v3/actions/self-hosted-runners/#create-a-registration-token-for-an-organization

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) CreateRegistrationTokenForOrg(ctx context.Context, req *CreateRegistrationTokenForOrgReq, opt ...requests.Option) (*CreateRegistrationTokenForOrgResponse, error) {
	return CreateRegistrationTokenForOrg(ctx, req, append(c, opt...)...)
}

/*
CreateRegistrationTokenForOrgReq is request data for Client.CreateRegistrationTokenForOrg

https://developer.github.com/v3/actions/self-hosted-runners/#create-a-registration-token-for-an-organization

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type CreateRegistrationTokenForOrgReq struct {
	_url string
	Org  string
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *CreateRegistrationTokenForOrgReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "POST",
		Options:     opt,
		URLPath:     fmt.Sprintf("/orgs/%v/actions/runners/registration-token", r.Org),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *CreateRegistrationTokenForOrgReq) Rel(link string, resp *CreateRegistrationTokenForOrgResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
CreateRegistrationTokenForOrgResponse is a response for CreateRegistrationTokenForOrg

https://developer.github.com/v3/actions/self-hosted-runners/#create-a-registration-token-for-an-organization
*/
type CreateRegistrationTokenForOrgResponse struct {
	httpResponse *http.Response
	Data         components.AuthenticationToken
}

// HTTPResponse returns the *http.Response
func (r *CreateRegistrationTokenForOrgResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *CreateRegistrationTokenForOrgResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{201})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{201}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
CreateRegistrationTokenForRepo performs requests for "actions/create-registration-token-for-repo"

Create a registration token for a repository.

  POST /repos/{owner}/{repo}/actions/runners/registration-token

https://developer.github.com/v3/actions/self-hosted-runners/#create-a-registration-token-for-a-repository
*/
func CreateRegistrationTokenForRepo(ctx context.Context, req *CreateRegistrationTokenForRepoReq, opt ...requests.Option) (*CreateRegistrationTokenForRepoResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(CreateRegistrationTokenForRepoReq)
	}
	resp := &CreateRegistrationTokenForRepoResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
CreateRegistrationTokenForRepo performs requests for "actions/create-registration-token-for-repo"

Create a registration token for a repository.

  POST /repos/{owner}/{repo}/actions/runners/registration-token

https://developer.github.com/v3/actions/self-hosted-runners/#create-a-registration-token-for-a-repository

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) CreateRegistrationTokenForRepo(ctx context.Context, req *CreateRegistrationTokenForRepoReq, opt ...requests.Option) (*CreateRegistrationTokenForRepoResponse, error) {
	return CreateRegistrationTokenForRepo(ctx, req, append(c, opt...)...)
}

/*
CreateRegistrationTokenForRepoReq is request data for Client.CreateRegistrationTokenForRepo

https://developer.github.com/v3/actions/self-hosted-runners/#create-a-registration-token-for-a-repository

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type CreateRegistrationTokenForRepoReq struct {
	_url  string
	Owner string
	Repo  string
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *CreateRegistrationTokenForRepoReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "POST",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/runners/registration-token", r.Owner, r.Repo),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *CreateRegistrationTokenForRepoReq) Rel(link string, resp *CreateRegistrationTokenForRepoResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
CreateRegistrationTokenForRepoResponse is a response for CreateRegistrationTokenForRepo

https://developer.github.com/v3/actions/self-hosted-runners/#create-a-registration-token-for-a-repository
*/
type CreateRegistrationTokenForRepoResponse struct {
	httpResponse *http.Response
	Data         components.AuthenticationToken
}

// HTTPResponse returns the *http.Response
func (r *CreateRegistrationTokenForRepoResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *CreateRegistrationTokenForRepoResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{201})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{201}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
CreateRemoveTokenForOrg performs requests for "actions/create-remove-token-for-org"

Create a remove token for an organization.

  POST /orgs/{org}/actions/runners/remove-token

https://developer.github.com/v3/actions/self-hosted-runners/#create-a-remove-token-for-an-organization
*/
func CreateRemoveTokenForOrg(ctx context.Context, req *CreateRemoveTokenForOrgReq, opt ...requests.Option) (*CreateRemoveTokenForOrgResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(CreateRemoveTokenForOrgReq)
	}
	resp := &CreateRemoveTokenForOrgResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
CreateRemoveTokenForOrg performs requests for "actions/create-remove-token-for-org"

Create a remove token for an organization.

  POST /orgs/{org}/actions/runners/remove-token

https://developer.github.com/v3/actions/self-hosted-runners/#create-a-remove-token-for-an-organization

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) CreateRemoveTokenForOrg(ctx context.Context, req *CreateRemoveTokenForOrgReq, opt ...requests.Option) (*CreateRemoveTokenForOrgResponse, error) {
	return CreateRemoveTokenForOrg(ctx, req, append(c, opt...)...)
}

/*
CreateRemoveTokenForOrgReq is request data for Client.CreateRemoveTokenForOrg

https://developer.github.com/v3/actions/self-hosted-runners/#create-a-remove-token-for-an-organization

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type CreateRemoveTokenForOrgReq struct {
	_url string
	Org  string
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *CreateRemoveTokenForOrgReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "POST",
		Options:     opt,
		URLPath:     fmt.Sprintf("/orgs/%v/actions/runners/remove-token", r.Org),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *CreateRemoveTokenForOrgReq) Rel(link string, resp *CreateRemoveTokenForOrgResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
CreateRemoveTokenForOrgResponse is a response for CreateRemoveTokenForOrg

https://developer.github.com/v3/actions/self-hosted-runners/#create-a-remove-token-for-an-organization
*/
type CreateRemoveTokenForOrgResponse struct {
	httpResponse *http.Response
	Data         components.AuthenticationToken
}

// HTTPResponse returns the *http.Response
func (r *CreateRemoveTokenForOrgResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *CreateRemoveTokenForOrgResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{201})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{201}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
CreateRemoveTokenForRepo performs requests for "actions/create-remove-token-for-repo"

Create a remove token for a repository.

  POST /repos/{owner}/{repo}/actions/runners/remove-token

https://developer.github.com/v3/actions/self-hosted-runners/#create-a-remove-token-for-a-repository
*/
func CreateRemoveTokenForRepo(ctx context.Context, req *CreateRemoveTokenForRepoReq, opt ...requests.Option) (*CreateRemoveTokenForRepoResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(CreateRemoveTokenForRepoReq)
	}
	resp := &CreateRemoveTokenForRepoResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
CreateRemoveTokenForRepo performs requests for "actions/create-remove-token-for-repo"

Create a remove token for a repository.

  POST /repos/{owner}/{repo}/actions/runners/remove-token

https://developer.github.com/v3/actions/self-hosted-runners/#create-a-remove-token-for-a-repository

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) CreateRemoveTokenForRepo(ctx context.Context, req *CreateRemoveTokenForRepoReq, opt ...requests.Option) (*CreateRemoveTokenForRepoResponse, error) {
	return CreateRemoveTokenForRepo(ctx, req, append(c, opt...)...)
}

/*
CreateRemoveTokenForRepoReq is request data for Client.CreateRemoveTokenForRepo

https://developer.github.com/v3/actions/self-hosted-runners/#create-a-remove-token-for-a-repository

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type CreateRemoveTokenForRepoReq struct {
	_url  string
	Owner string
	Repo  string
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *CreateRemoveTokenForRepoReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "POST",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/runners/remove-token", r.Owner, r.Repo),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *CreateRemoveTokenForRepoReq) Rel(link string, resp *CreateRemoveTokenForRepoResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
CreateRemoveTokenForRepoResponse is a response for CreateRemoveTokenForRepo

https://developer.github.com/v3/actions/self-hosted-runners/#create-a-remove-token-for-a-repository
*/
type CreateRemoveTokenForRepoResponse struct {
	httpResponse *http.Response
	Data         components.AuthenticationToken
}

// HTTPResponse returns the *http.Response
func (r *CreateRemoveTokenForRepoResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *CreateRemoveTokenForRepoResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{201})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{201}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
CreateWorkflowDispatch performs requests for "actions/create-workflow-dispatch"

Create a workflow dispatch event.

  POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches

https://developer.github.com/v3/actions/workflows/#create-a-workflow-dispatch-event
*/
func CreateWorkflowDispatch(ctx context.Context, req *CreateWorkflowDispatchReq, opt ...requests.Option) (*CreateWorkflowDispatchResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(CreateWorkflowDispatchReq)
	}
	resp := &CreateWorkflowDispatchResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
CreateWorkflowDispatch performs requests for "actions/create-workflow-dispatch"

Create a workflow dispatch event.

  POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches

https://developer.github.com/v3/actions/workflows/#create-a-workflow-dispatch-event

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) CreateWorkflowDispatch(ctx context.Context, req *CreateWorkflowDispatchReq, opt ...requests.Option) (*CreateWorkflowDispatchResponse, error) {
	return CreateWorkflowDispatch(ctx, req, append(c, opt...)...)
}

/*
CreateWorkflowDispatchReq is request data for Client.CreateWorkflowDispatch

https://developer.github.com/v3/actions/workflows/#create-a-workflow-dispatch-event

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type CreateWorkflowDispatchReq struct {
	_url        string
	Owner       string
	Repo        string
	WorkflowId  int64
	RequestBody CreateWorkflowDispatchReqBody
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *CreateWorkflowDispatchReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		Body:        r.RequestBody,
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"content-type": internal.String("application/json")},
		Method:      "POST",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/workflows/%v/dispatches", r.Owner, r.Repo, r.WorkflowId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *CreateWorkflowDispatchReq) Rel(link string, resp *CreateWorkflowDispatchResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
CreateWorkflowDispatchReqBody is a request body for actions/create-workflow-dispatch

https://developer.github.com/v3/actions/workflows/#create-a-workflow-dispatch-event
*/
type CreateWorkflowDispatchReqBody struct {

	/*
	Input keys and values configured in the workflow file. The maximum number of
	properties is 10. Any default properties configured in the workflow file will be
	used when `inputs` are omitted.
	*/
	Inputs map[string]string `json:"inputs,omitempty"`

	// The reference of the workflow run. The reference can be a branch, tag, or a commit SHA.
	Ref *string `json:"ref"`
}

/*
CreateWorkflowDispatchResponse is a response for CreateWorkflowDispatch

https://developer.github.com/v3/actions/workflows/#create-a-workflow-dispatch-event
*/
type CreateWorkflowDispatchResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *CreateWorkflowDispatchResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *CreateWorkflowDispatchResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{204})
	if err != nil {
		return err
	}
	return nil
}

/*
DeleteArtifact performs requests for "actions/delete-artifact"

Delete an artifact.

  DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}

https://developer.github.com/v3/actions/artifacts/#delete-an-artifact
*/
func DeleteArtifact(ctx context.Context, req *DeleteArtifactReq, opt ...requests.Option) (*DeleteArtifactResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(DeleteArtifactReq)
	}
	resp := &DeleteArtifactResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
DeleteArtifact performs requests for "actions/delete-artifact"

Delete an artifact.

  DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}

https://developer.github.com/v3/actions/artifacts/#delete-an-artifact

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) DeleteArtifact(ctx context.Context, req *DeleteArtifactReq, opt ...requests.Option) (*DeleteArtifactResponse, error) {
	return DeleteArtifact(ctx, req, append(c, opt...)...)
}

/*
DeleteArtifactReq is request data for Client.DeleteArtifact

https://developer.github.com/v3/actions/artifacts/#delete-an-artifact

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type DeleteArtifactReq struct {
	_url  string
	Owner string
	Repo  string

	// artifact_id parameter
	ArtifactId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *DeleteArtifactReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		Method:      "DELETE",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/artifacts/%v", r.Owner, r.Repo, r.ArtifactId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *DeleteArtifactReq) Rel(link string, resp *DeleteArtifactResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
DeleteArtifactResponse is a response for DeleteArtifact

https://developer.github.com/v3/actions/artifacts/#delete-an-artifact
*/
type DeleteArtifactResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *DeleteArtifactResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *DeleteArtifactResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{204})
	if err != nil {
		return err
	}
	return nil
}

/*
DeleteOrgSecret performs requests for "actions/delete-org-secret"

Delete an organization secret.

  DELETE /orgs/{org}/actions/secrets/{secret_name}

https://developer.github.com/v3/actions/secrets/#delete-an-organization-secret
*/
func DeleteOrgSecret(ctx context.Context, req *DeleteOrgSecretReq, opt ...requests.Option) (*DeleteOrgSecretResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(DeleteOrgSecretReq)
	}
	resp := &DeleteOrgSecretResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
DeleteOrgSecret performs requests for "actions/delete-org-secret"

Delete an organization secret.

  DELETE /orgs/{org}/actions/secrets/{secret_name}

https://developer.github.com/v3/actions/secrets/#delete-an-organization-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) DeleteOrgSecret(ctx context.Context, req *DeleteOrgSecretReq, opt ...requests.Option) (*DeleteOrgSecretResponse, error) {
	return DeleteOrgSecret(ctx, req, append(c, opt...)...)
}

/*
DeleteOrgSecretReq is request data for Client.DeleteOrgSecret

https://developer.github.com/v3/actions/secrets/#delete-an-organization-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type DeleteOrgSecretReq struct {
	_url string
	Org  string

	// secret_name parameter
	SecretName string
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *DeleteOrgSecretReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		Method:      "DELETE",
		Options:     opt,
		URLPath:     fmt.Sprintf("/orgs/%v/actions/secrets/%v", r.Org, r.SecretName),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *DeleteOrgSecretReq) Rel(link string, resp *DeleteOrgSecretResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
DeleteOrgSecretResponse is a response for DeleteOrgSecret

https://developer.github.com/v3/actions/secrets/#delete-an-organization-secret
*/
type DeleteOrgSecretResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *DeleteOrgSecretResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *DeleteOrgSecretResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{204})
	if err != nil {
		return err
	}
	return nil
}

/*
DeleteRepoSecret performs requests for "actions/delete-repo-secret"

Delete a repository secret.

  DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}

https://developer.github.com/v3/actions/secrets/#delete-a-repository-secret
*/
func DeleteRepoSecret(ctx context.Context, req *DeleteRepoSecretReq, opt ...requests.Option) (*DeleteRepoSecretResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(DeleteRepoSecretReq)
	}
	resp := &DeleteRepoSecretResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
DeleteRepoSecret performs requests for "actions/delete-repo-secret"

Delete a repository secret.

  DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}

https://developer.github.com/v3/actions/secrets/#delete-a-repository-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) DeleteRepoSecret(ctx context.Context, req *DeleteRepoSecretReq, opt ...requests.Option) (*DeleteRepoSecretResponse, error) {
	return DeleteRepoSecret(ctx, req, append(c, opt...)...)
}

/*
DeleteRepoSecretReq is request data for Client.DeleteRepoSecret

https://developer.github.com/v3/actions/secrets/#delete-a-repository-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type DeleteRepoSecretReq struct {
	_url  string
	Owner string
	Repo  string

	// secret_name parameter
	SecretName string
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *DeleteRepoSecretReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		Method:      "DELETE",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/secrets/%v", r.Owner, r.Repo, r.SecretName),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *DeleteRepoSecretReq) Rel(link string, resp *DeleteRepoSecretResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
DeleteRepoSecretResponse is a response for DeleteRepoSecret

https://developer.github.com/v3/actions/secrets/#delete-a-repository-secret
*/
type DeleteRepoSecretResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *DeleteRepoSecretResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *DeleteRepoSecretResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{204})
	if err != nil {
		return err
	}
	return nil
}

/*
DeleteSelfHostedRunnerFromOrg performs requests for "actions/delete-self-hosted-runner-from-org"

Delete a self-hosted runner from an organization.

  DELETE /orgs/{org}/actions/runners/{runner_id}

https://developer.github.com/v3/actions/self-hosted-runners/#delete-a-self-hosted-runner-from-an-organization
*/
func DeleteSelfHostedRunnerFromOrg(ctx context.Context, req *DeleteSelfHostedRunnerFromOrgReq, opt ...requests.Option) (*DeleteSelfHostedRunnerFromOrgResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(DeleteSelfHostedRunnerFromOrgReq)
	}
	resp := &DeleteSelfHostedRunnerFromOrgResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
DeleteSelfHostedRunnerFromOrg performs requests for "actions/delete-self-hosted-runner-from-org"

Delete a self-hosted runner from an organization.

  DELETE /orgs/{org}/actions/runners/{runner_id}

https://developer.github.com/v3/actions/self-hosted-runners/#delete-a-self-hosted-runner-from-an-organization

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) DeleteSelfHostedRunnerFromOrg(ctx context.Context, req *DeleteSelfHostedRunnerFromOrgReq, opt ...requests.Option) (*DeleteSelfHostedRunnerFromOrgResponse, error) {
	return DeleteSelfHostedRunnerFromOrg(ctx, req, append(c, opt...)...)
}

/*
DeleteSelfHostedRunnerFromOrgReq is request data for Client.DeleteSelfHostedRunnerFromOrg

https://developer.github.com/v3/actions/self-hosted-runners/#delete-a-self-hosted-runner-from-an-organization

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type DeleteSelfHostedRunnerFromOrgReq struct {
	_url string
	Org  string

	// runner_id parameter
	RunnerId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *DeleteSelfHostedRunnerFromOrgReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		Method:      "DELETE",
		Options:     opt,
		URLPath:     fmt.Sprintf("/orgs/%v/actions/runners/%v", r.Org, r.RunnerId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *DeleteSelfHostedRunnerFromOrgReq) Rel(link string, resp *DeleteSelfHostedRunnerFromOrgResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
DeleteSelfHostedRunnerFromOrgResponse is a response for DeleteSelfHostedRunnerFromOrg

https://developer.github.com/v3/actions/self-hosted-runners/#delete-a-self-hosted-runner-from-an-organization
*/
type DeleteSelfHostedRunnerFromOrgResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *DeleteSelfHostedRunnerFromOrgResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *DeleteSelfHostedRunnerFromOrgResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{204})
	if err != nil {
		return err
	}
	return nil
}

/*
DeleteSelfHostedRunnerFromRepo performs requests for "actions/delete-self-hosted-runner-from-repo"

Delete a self-hosted runner from a repository.

  DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}

https://developer.github.com/v3/actions/self-hosted-runners/#delete-a-self-hosted-runner-from-a-repository
*/
func DeleteSelfHostedRunnerFromRepo(ctx context.Context, req *DeleteSelfHostedRunnerFromRepoReq, opt ...requests.Option) (*DeleteSelfHostedRunnerFromRepoResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(DeleteSelfHostedRunnerFromRepoReq)
	}
	resp := &DeleteSelfHostedRunnerFromRepoResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
DeleteSelfHostedRunnerFromRepo performs requests for "actions/delete-self-hosted-runner-from-repo"

Delete a self-hosted runner from a repository.

  DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}

https://developer.github.com/v3/actions/self-hosted-runners/#delete-a-self-hosted-runner-from-a-repository

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) DeleteSelfHostedRunnerFromRepo(ctx context.Context, req *DeleteSelfHostedRunnerFromRepoReq, opt ...requests.Option) (*DeleteSelfHostedRunnerFromRepoResponse, error) {
	return DeleteSelfHostedRunnerFromRepo(ctx, req, append(c, opt...)...)
}

/*
DeleteSelfHostedRunnerFromRepoReq is request data for Client.DeleteSelfHostedRunnerFromRepo

https://developer.github.com/v3/actions/self-hosted-runners/#delete-a-self-hosted-runner-from-a-repository

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type DeleteSelfHostedRunnerFromRepoReq struct {
	_url  string
	Owner string
	Repo  string

	// runner_id parameter
	RunnerId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *DeleteSelfHostedRunnerFromRepoReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		Method:      "DELETE",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/runners/%v", r.Owner, r.Repo, r.RunnerId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *DeleteSelfHostedRunnerFromRepoReq) Rel(link string, resp *DeleteSelfHostedRunnerFromRepoResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
DeleteSelfHostedRunnerFromRepoResponse is a response for DeleteSelfHostedRunnerFromRepo

https://developer.github.com/v3/actions/self-hosted-runners/#delete-a-self-hosted-runner-from-a-repository
*/
type DeleteSelfHostedRunnerFromRepoResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *DeleteSelfHostedRunnerFromRepoResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *DeleteSelfHostedRunnerFromRepoResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{204})
	if err != nil {
		return err
	}
	return nil
}

/*
DeleteWorkflowRun performs requests for "actions/delete-workflow-run"

Delete a workflow run.

  DELETE /repos/{owner}/{repo}/actions/runs/{run_id}

https://developer.github.com/v3/actions/workflow-runs/#delete-a-workflow-run
*/
func DeleteWorkflowRun(ctx context.Context, req *DeleteWorkflowRunReq, opt ...requests.Option) (*DeleteWorkflowRunResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(DeleteWorkflowRunReq)
	}
	resp := &DeleteWorkflowRunResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
DeleteWorkflowRun performs requests for "actions/delete-workflow-run"

Delete a workflow run.

  DELETE /repos/{owner}/{repo}/actions/runs/{run_id}

https://developer.github.com/v3/actions/workflow-runs/#delete-a-workflow-run

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) DeleteWorkflowRun(ctx context.Context, req *DeleteWorkflowRunReq, opt ...requests.Option) (*DeleteWorkflowRunResponse, error) {
	return DeleteWorkflowRun(ctx, req, append(c, opt...)...)
}

/*
DeleteWorkflowRunReq is request data for Client.DeleteWorkflowRun

https://developer.github.com/v3/actions/workflow-runs/#delete-a-workflow-run

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type DeleteWorkflowRunReq struct {
	_url  string
	Owner string
	Repo  string
	RunId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *DeleteWorkflowRunReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		Method:      "DELETE",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/runs/%v", r.Owner, r.Repo, r.RunId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *DeleteWorkflowRunReq) Rel(link string, resp *DeleteWorkflowRunResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
DeleteWorkflowRunResponse is a response for DeleteWorkflowRun

https://developer.github.com/v3/actions/workflow-runs/#delete-a-workflow-run
*/
type DeleteWorkflowRunResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *DeleteWorkflowRunResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *DeleteWorkflowRunResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{204})
	if err != nil {
		return err
	}
	return nil
}

/*
DeleteWorkflowRunLogs performs requests for "actions/delete-workflow-run-logs"

Delete workflow run logs.

  DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs

https://developer.github.com/v3/actions/workflow-runs/#delete-workflow-run-logs
*/
func DeleteWorkflowRunLogs(ctx context.Context, req *DeleteWorkflowRunLogsReq, opt ...requests.Option) (*DeleteWorkflowRunLogsResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(DeleteWorkflowRunLogsReq)
	}
	resp := &DeleteWorkflowRunLogsResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
DeleteWorkflowRunLogs performs requests for "actions/delete-workflow-run-logs"

Delete workflow run logs.

  DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs

https://developer.github.com/v3/actions/workflow-runs/#delete-workflow-run-logs

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) DeleteWorkflowRunLogs(ctx context.Context, req *DeleteWorkflowRunLogsReq, opt ...requests.Option) (*DeleteWorkflowRunLogsResponse, error) {
	return DeleteWorkflowRunLogs(ctx, req, append(c, opt...)...)
}

/*
DeleteWorkflowRunLogsReq is request data for Client.DeleteWorkflowRunLogs

https://developer.github.com/v3/actions/workflow-runs/#delete-workflow-run-logs

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type DeleteWorkflowRunLogsReq struct {
	_url  string
	Owner string
	Repo  string
	RunId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *DeleteWorkflowRunLogsReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		Method:      "DELETE",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/runs/%v/logs", r.Owner, r.Repo, r.RunId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *DeleteWorkflowRunLogsReq) Rel(link string, resp *DeleteWorkflowRunLogsResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
DeleteWorkflowRunLogsResponse is a response for DeleteWorkflowRunLogs

https://developer.github.com/v3/actions/workflow-runs/#delete-workflow-run-logs
*/
type DeleteWorkflowRunLogsResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *DeleteWorkflowRunLogsResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *DeleteWorkflowRunLogsResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{204})
	if err != nil {
		return err
	}
	return nil
}

/*
DownloadArtifact performs requests for "actions/download-artifact"

Download an artifact.

  GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}

https://developer.github.com/v3/actions/artifacts/#download-an-artifact
*/
func DownloadArtifact(ctx context.Context, req *DownloadArtifactReq, opt ...requests.Option) (*DownloadArtifactResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(DownloadArtifactReq)
	}
	resp := &DownloadArtifactResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
DownloadArtifact performs requests for "actions/download-artifact"

Download an artifact.

  GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}

https://developer.github.com/v3/actions/artifacts/#download-an-artifact

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) DownloadArtifact(ctx context.Context, req *DownloadArtifactReq, opt ...requests.Option) (*DownloadArtifactResponse, error) {
	return DownloadArtifact(ctx, req, append(c, opt...)...)
}

/*
DownloadArtifactReq is request data for Client.DownloadArtifact

https://developer.github.com/v3/actions/artifacts/#download-an-artifact

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type DownloadArtifactReq struct {
	_url  string
	Owner string
	Repo  string

	// artifact_id parameter
	ArtifactId int64

	// archive_format parameter
	ArchiveFormat string
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *DownloadArtifactReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/artifacts/%v/%v", r.Owner, r.Repo, r.ArtifactId, r.ArchiveFormat),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *DownloadArtifactReq) Rel(link string, resp *DownloadArtifactResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
DownloadArtifactResponse is a response for DownloadArtifact

https://developer.github.com/v3/actions/artifacts/#download-an-artifact
*/
type DownloadArtifactResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *DownloadArtifactResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *DownloadArtifactResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{302})
	if err != nil {
		return err
	}
	return nil
}

/*
DownloadJobLogsForWorkflowRun performs requests for "actions/download-job-logs-for-workflow-run"

Download job logs for a workflow run.

  GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs

https://developer.github.com/v3/actions/workflow-jobs/#download-job-logs-for-a-workflow-run
*/
func DownloadJobLogsForWorkflowRun(ctx context.Context, req *DownloadJobLogsForWorkflowRunReq, opt ...requests.Option) (*DownloadJobLogsForWorkflowRunResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(DownloadJobLogsForWorkflowRunReq)
	}
	resp := &DownloadJobLogsForWorkflowRunResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
DownloadJobLogsForWorkflowRun performs requests for "actions/download-job-logs-for-workflow-run"

Download job logs for a workflow run.

  GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs

https://developer.github.com/v3/actions/workflow-jobs/#download-job-logs-for-a-workflow-run

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) DownloadJobLogsForWorkflowRun(ctx context.Context, req *DownloadJobLogsForWorkflowRunReq, opt ...requests.Option) (*DownloadJobLogsForWorkflowRunResponse, error) {
	return DownloadJobLogsForWorkflowRun(ctx, req, append(c, opt...)...)
}

/*
DownloadJobLogsForWorkflowRunReq is request data for Client.DownloadJobLogsForWorkflowRun

https://developer.github.com/v3/actions/workflow-jobs/#download-job-logs-for-a-workflow-run

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type DownloadJobLogsForWorkflowRunReq struct {
	_url  string
	Owner string
	Repo  string

	// job_id parameter
	JobId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *DownloadJobLogsForWorkflowRunReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/jobs/%v/logs", r.Owner, r.Repo, r.JobId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *DownloadJobLogsForWorkflowRunReq) Rel(link string, resp *DownloadJobLogsForWorkflowRunResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
DownloadJobLogsForWorkflowRunResponse is a response for DownloadJobLogsForWorkflowRun

https://developer.github.com/v3/actions/workflow-jobs/#download-job-logs-for-a-workflow-run
*/
type DownloadJobLogsForWorkflowRunResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *DownloadJobLogsForWorkflowRunResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *DownloadJobLogsForWorkflowRunResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{302})
	if err != nil {
		return err
	}
	return nil
}

/*
DownloadWorkflowRunLogs performs requests for "actions/download-workflow-run-logs"

Download workflow run logs.

  GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs

https://developer.github.com/v3/actions/workflow-runs/#download-workflow-run-logs
*/
func DownloadWorkflowRunLogs(ctx context.Context, req *DownloadWorkflowRunLogsReq, opt ...requests.Option) (*DownloadWorkflowRunLogsResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(DownloadWorkflowRunLogsReq)
	}
	resp := &DownloadWorkflowRunLogsResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
DownloadWorkflowRunLogs performs requests for "actions/download-workflow-run-logs"

Download workflow run logs.

  GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs

https://developer.github.com/v3/actions/workflow-runs/#download-workflow-run-logs

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) DownloadWorkflowRunLogs(ctx context.Context, req *DownloadWorkflowRunLogsReq, opt ...requests.Option) (*DownloadWorkflowRunLogsResponse, error) {
	return DownloadWorkflowRunLogs(ctx, req, append(c, opt...)...)
}

/*
DownloadWorkflowRunLogsReq is request data for Client.DownloadWorkflowRunLogs

https://developer.github.com/v3/actions/workflow-runs/#download-workflow-run-logs

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type DownloadWorkflowRunLogsReq struct {
	_url  string
	Owner string
	Repo  string
	RunId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *DownloadWorkflowRunLogsReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/runs/%v/logs", r.Owner, r.Repo, r.RunId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *DownloadWorkflowRunLogsReq) Rel(link string, resp *DownloadWorkflowRunLogsResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
DownloadWorkflowRunLogsResponse is a response for DownloadWorkflowRunLogs

https://developer.github.com/v3/actions/workflow-runs/#download-workflow-run-logs
*/
type DownloadWorkflowRunLogsResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *DownloadWorkflowRunLogsResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *DownloadWorkflowRunLogsResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{302})
	if err != nil {
		return err
	}
	return nil
}

/*
GetArtifact performs requests for "actions/get-artifact"

Get an artifact.

  GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}

https://developer.github.com/v3/actions/artifacts/#get-an-artifact
*/
func GetArtifact(ctx context.Context, req *GetArtifactReq, opt ...requests.Option) (*GetArtifactResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(GetArtifactReq)
	}
	resp := &GetArtifactResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
GetArtifact performs requests for "actions/get-artifact"

Get an artifact.

  GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}

https://developer.github.com/v3/actions/artifacts/#get-an-artifact

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) GetArtifact(ctx context.Context, req *GetArtifactReq, opt ...requests.Option) (*GetArtifactResponse, error) {
	return GetArtifact(ctx, req, append(c, opt...)...)
}

/*
GetArtifactReq is request data for Client.GetArtifact

https://developer.github.com/v3/actions/artifacts/#get-an-artifact

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type GetArtifactReq struct {
	_url  string
	Owner string
	Repo  string

	// artifact_id parameter
	ArtifactId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *GetArtifactReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/artifacts/%v", r.Owner, r.Repo, r.ArtifactId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *GetArtifactReq) Rel(link string, resp *GetArtifactResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
GetArtifactResponse is a response for GetArtifact

https://developer.github.com/v3/actions/artifacts/#get-an-artifact
*/
type GetArtifactResponse struct {
	httpResponse *http.Response
	Data         components.Artifact
}

// HTTPResponse returns the *http.Response
func (r *GetArtifactResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *GetArtifactResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
GetJobForWorkflowRun performs requests for "actions/get-job-for-workflow-run"

Get a job for a workflow run.

  GET /repos/{owner}/{repo}/actions/jobs/{job_id}

https://developer.github.com/v3/actions/workflow-jobs/#get-a-job-for-a-workflow-run
*/
func GetJobForWorkflowRun(ctx context.Context, req *GetJobForWorkflowRunReq, opt ...requests.Option) (*GetJobForWorkflowRunResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(GetJobForWorkflowRunReq)
	}
	resp := &GetJobForWorkflowRunResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
GetJobForWorkflowRun performs requests for "actions/get-job-for-workflow-run"

Get a job for a workflow run.

  GET /repos/{owner}/{repo}/actions/jobs/{job_id}

https://developer.github.com/v3/actions/workflow-jobs/#get-a-job-for-a-workflow-run

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) GetJobForWorkflowRun(ctx context.Context, req *GetJobForWorkflowRunReq, opt ...requests.Option) (*GetJobForWorkflowRunResponse, error) {
	return GetJobForWorkflowRun(ctx, req, append(c, opt...)...)
}

/*
GetJobForWorkflowRunReq is request data for Client.GetJobForWorkflowRun

https://developer.github.com/v3/actions/workflow-jobs/#get-a-job-for-a-workflow-run

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type GetJobForWorkflowRunReq struct {
	_url  string
	Owner string
	Repo  string

	// job_id parameter
	JobId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *GetJobForWorkflowRunReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/jobs/%v", r.Owner, r.Repo, r.JobId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *GetJobForWorkflowRunReq) Rel(link string, resp *GetJobForWorkflowRunResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
GetJobForWorkflowRunResponse is a response for GetJobForWorkflowRun

https://developer.github.com/v3/actions/workflow-jobs/#get-a-job-for-a-workflow-run
*/
type GetJobForWorkflowRunResponse struct {
	httpResponse *http.Response
	Data         components.Job
}

// HTTPResponse returns the *http.Response
func (r *GetJobForWorkflowRunResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *GetJobForWorkflowRunResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{202})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{202}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
GetOrgPublicKey performs requests for "actions/get-org-public-key"

Get an organization public key.

  GET /orgs/{org}/actions/secrets/public-key

https://developer.github.com/v3/actions/secrets/#get-an-organization-public-key
*/
func GetOrgPublicKey(ctx context.Context, req *GetOrgPublicKeyReq, opt ...requests.Option) (*GetOrgPublicKeyResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(GetOrgPublicKeyReq)
	}
	resp := &GetOrgPublicKeyResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
GetOrgPublicKey performs requests for "actions/get-org-public-key"

Get an organization public key.

  GET /orgs/{org}/actions/secrets/public-key

https://developer.github.com/v3/actions/secrets/#get-an-organization-public-key

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) GetOrgPublicKey(ctx context.Context, req *GetOrgPublicKeyReq, opt ...requests.Option) (*GetOrgPublicKeyResponse, error) {
	return GetOrgPublicKey(ctx, req, append(c, opt...)...)
}

/*
GetOrgPublicKeyReq is request data for Client.GetOrgPublicKey

https://developer.github.com/v3/actions/secrets/#get-an-organization-public-key

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type GetOrgPublicKeyReq struct {
	_url string
	Org  string
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *GetOrgPublicKeyReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/orgs/%v/actions/secrets/public-key", r.Org),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *GetOrgPublicKeyReq) Rel(link string, resp *GetOrgPublicKeyResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
GetOrgPublicKeyResponse is a response for GetOrgPublicKey

https://developer.github.com/v3/actions/secrets/#get-an-organization-public-key
*/
type GetOrgPublicKeyResponse struct {
	httpResponse *http.Response
	Data         components.ActionsPublicKey
}

// HTTPResponse returns the *http.Response
func (r *GetOrgPublicKeyResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *GetOrgPublicKeyResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
GetOrgSecret performs requests for "actions/get-org-secret"

Get an organization secret.

  GET /orgs/{org}/actions/secrets/{secret_name}

https://developer.github.com/v3/actions/secrets/#get-an-organization-secret
*/
func GetOrgSecret(ctx context.Context, req *GetOrgSecretReq, opt ...requests.Option) (*GetOrgSecretResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(GetOrgSecretReq)
	}
	resp := &GetOrgSecretResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
GetOrgSecret performs requests for "actions/get-org-secret"

Get an organization secret.

  GET /orgs/{org}/actions/secrets/{secret_name}

https://developer.github.com/v3/actions/secrets/#get-an-organization-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) GetOrgSecret(ctx context.Context, req *GetOrgSecretReq, opt ...requests.Option) (*GetOrgSecretResponse, error) {
	return GetOrgSecret(ctx, req, append(c, opt...)...)
}

/*
GetOrgSecretReq is request data for Client.GetOrgSecret

https://developer.github.com/v3/actions/secrets/#get-an-organization-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type GetOrgSecretReq struct {
	_url string
	Org  string

	// secret_name parameter
	SecretName string
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *GetOrgSecretReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/orgs/%v/actions/secrets/%v", r.Org, r.SecretName),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *GetOrgSecretReq) Rel(link string, resp *GetOrgSecretResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
GetOrgSecretResponse is a response for GetOrgSecret

https://developer.github.com/v3/actions/secrets/#get-an-organization-secret
*/
type GetOrgSecretResponse struct {
	httpResponse *http.Response
	Data         components.OrganizationActionsSecret
}

// HTTPResponse returns the *http.Response
func (r *GetOrgSecretResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *GetOrgSecretResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
GetRepoPublicKey performs requests for "actions/get-repo-public-key"

Get a repository public key.

  GET /repos/{owner}/{repo}/actions/secrets/public-key

https://developer.github.com/v3/actions/secrets/#get-a-repository-public-key
*/
func GetRepoPublicKey(ctx context.Context, req *GetRepoPublicKeyReq, opt ...requests.Option) (*GetRepoPublicKeyResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(GetRepoPublicKeyReq)
	}
	resp := &GetRepoPublicKeyResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
GetRepoPublicKey performs requests for "actions/get-repo-public-key"

Get a repository public key.

  GET /repos/{owner}/{repo}/actions/secrets/public-key

https://developer.github.com/v3/actions/secrets/#get-a-repository-public-key

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) GetRepoPublicKey(ctx context.Context, req *GetRepoPublicKeyReq, opt ...requests.Option) (*GetRepoPublicKeyResponse, error) {
	return GetRepoPublicKey(ctx, req, append(c, opt...)...)
}

/*
GetRepoPublicKeyReq is request data for Client.GetRepoPublicKey

https://developer.github.com/v3/actions/secrets/#get-a-repository-public-key

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type GetRepoPublicKeyReq struct {
	_url  string
	Owner string
	Repo  string
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *GetRepoPublicKeyReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/secrets/public-key", r.Owner, r.Repo),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *GetRepoPublicKeyReq) Rel(link string, resp *GetRepoPublicKeyResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
GetRepoPublicKeyResponse is a response for GetRepoPublicKey

https://developer.github.com/v3/actions/secrets/#get-a-repository-public-key
*/
type GetRepoPublicKeyResponse struct {
	httpResponse *http.Response
	Data         components.ActionsPublicKey
}

// HTTPResponse returns the *http.Response
func (r *GetRepoPublicKeyResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *GetRepoPublicKeyResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
GetRepoSecret performs requests for "actions/get-repo-secret"

Get a repository secret.

  GET /repos/{owner}/{repo}/actions/secrets/{secret_name}

https://developer.github.com/v3/actions/secrets/#get-a-repository-secret
*/
func GetRepoSecret(ctx context.Context, req *GetRepoSecretReq, opt ...requests.Option) (*GetRepoSecretResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(GetRepoSecretReq)
	}
	resp := &GetRepoSecretResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
GetRepoSecret performs requests for "actions/get-repo-secret"

Get a repository secret.

  GET /repos/{owner}/{repo}/actions/secrets/{secret_name}

https://developer.github.com/v3/actions/secrets/#get-a-repository-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) GetRepoSecret(ctx context.Context, req *GetRepoSecretReq, opt ...requests.Option) (*GetRepoSecretResponse, error) {
	return GetRepoSecret(ctx, req, append(c, opt...)...)
}

/*
GetRepoSecretReq is request data for Client.GetRepoSecret

https://developer.github.com/v3/actions/secrets/#get-a-repository-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type GetRepoSecretReq struct {
	_url  string
	Owner string
	Repo  string

	// secret_name parameter
	SecretName string
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *GetRepoSecretReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/secrets/%v", r.Owner, r.Repo, r.SecretName),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *GetRepoSecretReq) Rel(link string, resp *GetRepoSecretResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
GetRepoSecretResponse is a response for GetRepoSecret

https://developer.github.com/v3/actions/secrets/#get-a-repository-secret
*/
type GetRepoSecretResponse struct {
	httpResponse *http.Response
	Data         components.ActionsSecret
}

// HTTPResponse returns the *http.Response
func (r *GetRepoSecretResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *GetRepoSecretResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
GetSelfHostedRunnerForOrg performs requests for "actions/get-self-hosted-runner-for-org"

Get a self-hosted runner for an organization.

  GET /orgs/{org}/actions/runners/{runner_id}

https://developer.github.com/v3/actions/self-hosted-runners/#get-a-self-hosted-runner-for-an-organization
*/
func GetSelfHostedRunnerForOrg(ctx context.Context, req *GetSelfHostedRunnerForOrgReq, opt ...requests.Option) (*GetSelfHostedRunnerForOrgResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(GetSelfHostedRunnerForOrgReq)
	}
	resp := &GetSelfHostedRunnerForOrgResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
GetSelfHostedRunnerForOrg performs requests for "actions/get-self-hosted-runner-for-org"

Get a self-hosted runner for an organization.

  GET /orgs/{org}/actions/runners/{runner_id}

https://developer.github.com/v3/actions/self-hosted-runners/#get-a-self-hosted-runner-for-an-organization

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) GetSelfHostedRunnerForOrg(ctx context.Context, req *GetSelfHostedRunnerForOrgReq, opt ...requests.Option) (*GetSelfHostedRunnerForOrgResponse, error) {
	return GetSelfHostedRunnerForOrg(ctx, req, append(c, opt...)...)
}

/*
GetSelfHostedRunnerForOrgReq is request data for Client.GetSelfHostedRunnerForOrg

https://developer.github.com/v3/actions/self-hosted-runners/#get-a-self-hosted-runner-for-an-organization

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type GetSelfHostedRunnerForOrgReq struct {
	_url string
	Org  string

	// runner_id parameter
	RunnerId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *GetSelfHostedRunnerForOrgReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/orgs/%v/actions/runners/%v", r.Org, r.RunnerId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *GetSelfHostedRunnerForOrgReq) Rel(link string, resp *GetSelfHostedRunnerForOrgResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
GetSelfHostedRunnerForOrgResponse is a response for GetSelfHostedRunnerForOrg

https://developer.github.com/v3/actions/self-hosted-runners/#get-a-self-hosted-runner-for-an-organization
*/
type GetSelfHostedRunnerForOrgResponse struct {
	httpResponse *http.Response
	Data         components.Runner
}

// HTTPResponse returns the *http.Response
func (r *GetSelfHostedRunnerForOrgResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *GetSelfHostedRunnerForOrgResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
GetSelfHostedRunnerForRepo performs requests for "actions/get-self-hosted-runner-for-repo"

Get a self-hosted runner for a repository.

  GET /repos/{owner}/{repo}/actions/runners/{runner_id}

https://developer.github.com/v3/actions/self-hosted-runners/#get-a-self-hosted-runner-for-a-repository
*/
func GetSelfHostedRunnerForRepo(ctx context.Context, req *GetSelfHostedRunnerForRepoReq, opt ...requests.Option) (*GetSelfHostedRunnerForRepoResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(GetSelfHostedRunnerForRepoReq)
	}
	resp := &GetSelfHostedRunnerForRepoResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
GetSelfHostedRunnerForRepo performs requests for "actions/get-self-hosted-runner-for-repo"

Get a self-hosted runner for a repository.

  GET /repos/{owner}/{repo}/actions/runners/{runner_id}

https://developer.github.com/v3/actions/self-hosted-runners/#get-a-self-hosted-runner-for-a-repository

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) GetSelfHostedRunnerForRepo(ctx context.Context, req *GetSelfHostedRunnerForRepoReq, opt ...requests.Option) (*GetSelfHostedRunnerForRepoResponse, error) {
	return GetSelfHostedRunnerForRepo(ctx, req, append(c, opt...)...)
}

/*
GetSelfHostedRunnerForRepoReq is request data for Client.GetSelfHostedRunnerForRepo

https://developer.github.com/v3/actions/self-hosted-runners/#get-a-self-hosted-runner-for-a-repository

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type GetSelfHostedRunnerForRepoReq struct {
	_url  string
	Owner string
	Repo  string

	// runner_id parameter
	RunnerId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *GetSelfHostedRunnerForRepoReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/runners/%v", r.Owner, r.Repo, r.RunnerId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *GetSelfHostedRunnerForRepoReq) Rel(link string, resp *GetSelfHostedRunnerForRepoResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
GetSelfHostedRunnerForRepoResponse is a response for GetSelfHostedRunnerForRepo

https://developer.github.com/v3/actions/self-hosted-runners/#get-a-self-hosted-runner-for-a-repository
*/
type GetSelfHostedRunnerForRepoResponse struct {
	httpResponse *http.Response
	Data         components.Runner
}

// HTTPResponse returns the *http.Response
func (r *GetSelfHostedRunnerForRepoResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *GetSelfHostedRunnerForRepoResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
GetWorkflow performs requests for "actions/get-workflow"

Get a workflow.

  GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}

https://developer.github.com/v3/actions/workflows/#get-a-workflow
*/
func GetWorkflow(ctx context.Context, req *GetWorkflowReq, opt ...requests.Option) (*GetWorkflowResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(GetWorkflowReq)
	}
	resp := &GetWorkflowResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
GetWorkflow performs requests for "actions/get-workflow"

Get a workflow.

  GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}

https://developer.github.com/v3/actions/workflows/#get-a-workflow

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) GetWorkflow(ctx context.Context, req *GetWorkflowReq, opt ...requests.Option) (*GetWorkflowResponse, error) {
	return GetWorkflow(ctx, req, append(c, opt...)...)
}

/*
GetWorkflowReq is request data for Client.GetWorkflow

https://developer.github.com/v3/actions/workflows/#get-a-workflow

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type GetWorkflowReq struct {
	_url       string
	Owner      string
	Repo       string
	WorkflowId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *GetWorkflowReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/workflows/%v", r.Owner, r.Repo, r.WorkflowId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *GetWorkflowReq) Rel(link string, resp *GetWorkflowResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
GetWorkflowResponse is a response for GetWorkflow

https://developer.github.com/v3/actions/workflows/#get-a-workflow
*/
type GetWorkflowResponse struct {
	httpResponse *http.Response
	Data         components.Workflow
}

// HTTPResponse returns the *http.Response
func (r *GetWorkflowResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *GetWorkflowResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
GetWorkflowRun performs requests for "actions/get-workflow-run"

Get a workflow run.

  GET /repos/{owner}/{repo}/actions/runs/{run_id}

https://developer.github.com/v3/actions/workflow-runs/#get-a-workflow-run
*/
func GetWorkflowRun(ctx context.Context, req *GetWorkflowRunReq, opt ...requests.Option) (*GetWorkflowRunResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(GetWorkflowRunReq)
	}
	resp := &GetWorkflowRunResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
GetWorkflowRun performs requests for "actions/get-workflow-run"

Get a workflow run.

  GET /repos/{owner}/{repo}/actions/runs/{run_id}

https://developer.github.com/v3/actions/workflow-runs/#get-a-workflow-run

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) GetWorkflowRun(ctx context.Context, req *GetWorkflowRunReq, opt ...requests.Option) (*GetWorkflowRunResponse, error) {
	return GetWorkflowRun(ctx, req, append(c, opt...)...)
}

/*
GetWorkflowRunReq is request data for Client.GetWorkflowRun

https://developer.github.com/v3/actions/workflow-runs/#get-a-workflow-run

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type GetWorkflowRunReq struct {
	_url  string
	Owner string
	Repo  string
	RunId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *GetWorkflowRunReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/runs/%v", r.Owner, r.Repo, r.RunId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *GetWorkflowRunReq) Rel(link string, resp *GetWorkflowRunResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
GetWorkflowRunResponse is a response for GetWorkflowRun

https://developer.github.com/v3/actions/workflow-runs/#get-a-workflow-run
*/
type GetWorkflowRunResponse struct {
	httpResponse *http.Response
	Data         components.WorkflowRun
}

// HTTPResponse returns the *http.Response
func (r *GetWorkflowRunResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *GetWorkflowRunResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
GetWorkflowRunUsage performs requests for "actions/get-workflow-run-usage"

Get workflow run usage.

  GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing

https://developer.github.com/v3/actions/workflow-runs/#get-workflow-run-usage
*/
func GetWorkflowRunUsage(ctx context.Context, req *GetWorkflowRunUsageReq, opt ...requests.Option) (*GetWorkflowRunUsageResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(GetWorkflowRunUsageReq)
	}
	resp := &GetWorkflowRunUsageResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
GetWorkflowRunUsage performs requests for "actions/get-workflow-run-usage"

Get workflow run usage.

  GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing

https://developer.github.com/v3/actions/workflow-runs/#get-workflow-run-usage

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) GetWorkflowRunUsage(ctx context.Context, req *GetWorkflowRunUsageReq, opt ...requests.Option) (*GetWorkflowRunUsageResponse, error) {
	return GetWorkflowRunUsage(ctx, req, append(c, opt...)...)
}

/*
GetWorkflowRunUsageReq is request data for Client.GetWorkflowRunUsage

https://developer.github.com/v3/actions/workflow-runs/#get-workflow-run-usage

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type GetWorkflowRunUsageReq struct {
	_url  string
	Owner string
	Repo  string
	RunId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *GetWorkflowRunUsageReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/runs/%v/timing", r.Owner, r.Repo, r.RunId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *GetWorkflowRunUsageReq) Rel(link string, resp *GetWorkflowRunUsageResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
GetWorkflowRunUsageResponse is a response for GetWorkflowRunUsage

https://developer.github.com/v3/actions/workflow-runs/#get-workflow-run-usage
*/
type GetWorkflowRunUsageResponse struct {
	httpResponse *http.Response
	Data         components.WorkflowRunUsage
}

// HTTPResponse returns the *http.Response
func (r *GetWorkflowRunUsageResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *GetWorkflowRunUsageResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
GetWorkflowUsage performs requests for "actions/get-workflow-usage"

Get workflow usage.

  GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing

https://developer.github.com/v3/actions/workflows/#get-workflow-usage
*/
func GetWorkflowUsage(ctx context.Context, req *GetWorkflowUsageReq, opt ...requests.Option) (*GetWorkflowUsageResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(GetWorkflowUsageReq)
	}
	resp := &GetWorkflowUsageResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
GetWorkflowUsage performs requests for "actions/get-workflow-usage"

Get workflow usage.

  GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing

https://developer.github.com/v3/actions/workflows/#get-workflow-usage

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) GetWorkflowUsage(ctx context.Context, req *GetWorkflowUsageReq, opt ...requests.Option) (*GetWorkflowUsageResponse, error) {
	return GetWorkflowUsage(ctx, req, append(c, opt...)...)
}

/*
GetWorkflowUsageReq is request data for Client.GetWorkflowUsage

https://developer.github.com/v3/actions/workflows/#get-workflow-usage

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type GetWorkflowUsageReq struct {
	_url       string
	Owner      string
	Repo       string
	WorkflowId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *GetWorkflowUsageReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/workflows/%v/timing", r.Owner, r.Repo, r.WorkflowId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *GetWorkflowUsageReq) Rel(link string, resp *GetWorkflowUsageResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
GetWorkflowUsageResponse is a response for GetWorkflowUsage

https://developer.github.com/v3/actions/workflows/#get-workflow-usage
*/
type GetWorkflowUsageResponse struct {
	httpResponse *http.Response
	Data         components.WorkflowUsage
}

// HTTPResponse returns the *http.Response
func (r *GetWorkflowUsageResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *GetWorkflowUsageResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
ListArtifactsForRepo performs requests for "actions/list-artifacts-for-repo"

List artifacts for a repository.

  GET /repos/{owner}/{repo}/actions/artifacts

https://developer.github.com/v3/actions/artifacts/#list-artifacts-for-a-repository
*/
func ListArtifactsForRepo(ctx context.Context, req *ListArtifactsForRepoReq, opt ...requests.Option) (*ListArtifactsForRepoResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(ListArtifactsForRepoReq)
	}
	resp := &ListArtifactsForRepoResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
ListArtifactsForRepo performs requests for "actions/list-artifacts-for-repo"

List artifacts for a repository.

  GET /repos/{owner}/{repo}/actions/artifacts

https://developer.github.com/v3/actions/artifacts/#list-artifacts-for-a-repository

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) ListArtifactsForRepo(ctx context.Context, req *ListArtifactsForRepoReq, opt ...requests.Option) (*ListArtifactsForRepoResponse, error) {
	return ListArtifactsForRepo(ctx, req, append(c, opt...)...)
}

/*
ListArtifactsForRepoReq is request data for Client.ListArtifactsForRepo

https://developer.github.com/v3/actions/artifacts/#list-artifacts-for-a-repository

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type ListArtifactsForRepoReq struct {
	_url  string
	Owner string
	Repo  string

	// Results per page (max 100)
	PerPage *int64

	// Page number of the results to fetch.
	Page *int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *ListArtifactsForRepoReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	query := url.Values{}
	if r.PerPage != nil {
		query.Set("per_page", strconv.FormatInt(*r.PerPage, 10))
	}
	if r.Page != nil {
		query.Set("page", strconv.FormatInt(*r.Page, 10))
	}

	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/artifacts", r.Owner, r.Repo),
		URLQuery:    query,
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *ListArtifactsForRepoReq) Rel(link string, resp *ListArtifactsForRepoResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
ListArtifactsForRepoResponseBody is a response body for ListArtifactsForRepo

https://developer.github.com/v3/actions/artifacts/#list-artifacts-for-a-repository
*/
type ListArtifactsForRepoResponseBody struct {
	Artifacts  []components.Artifact `json:"artifacts,omitempty"`
	TotalCount int64                 `json:"total_count,omitempty"`
}

/*
ListArtifactsForRepoResponse is a response for ListArtifactsForRepo

https://developer.github.com/v3/actions/artifacts/#list-artifacts-for-a-repository
*/
type ListArtifactsForRepoResponse struct {
	httpResponse *http.Response
	Data         ListArtifactsForRepoResponseBody
}

// HTTPResponse returns the *http.Response
func (r *ListArtifactsForRepoResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *ListArtifactsForRepoResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
ListJobsForWorkflowRun performs requests for "actions/list-jobs-for-workflow-run"

List jobs for a workflow run.

  GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs

https://developer.github.com/v3/actions/workflow-jobs/#list-jobs-for-a-workflow-run
*/
func ListJobsForWorkflowRun(ctx context.Context, req *ListJobsForWorkflowRunReq, opt ...requests.Option) (*ListJobsForWorkflowRunResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(ListJobsForWorkflowRunReq)
	}
	resp := &ListJobsForWorkflowRunResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
ListJobsForWorkflowRun performs requests for "actions/list-jobs-for-workflow-run"

List jobs for a workflow run.

  GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs

https://developer.github.com/v3/actions/workflow-jobs/#list-jobs-for-a-workflow-run

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) ListJobsForWorkflowRun(ctx context.Context, req *ListJobsForWorkflowRunReq, opt ...requests.Option) (*ListJobsForWorkflowRunResponse, error) {
	return ListJobsForWorkflowRun(ctx, req, append(c, opt...)...)
}

/*
ListJobsForWorkflowRunReq is request data for Client.ListJobsForWorkflowRun

https://developer.github.com/v3/actions/workflow-jobs/#list-jobs-for-a-workflow-run

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type ListJobsForWorkflowRunReq struct {
	_url  string
	Owner string
	Repo  string
	RunId int64

	/*
	Filters jobs by their `completed_at` timestamp. Can be one of:
	\* `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.
	*/
	Filter *string

	// Results per page (max 100)
	PerPage *int64

	// Page number of the results to fetch.
	Page *int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *ListJobsForWorkflowRunReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	query := url.Values{}
	if r.Filter != nil {
		query.Set("filter", *r.Filter)
	}
	if r.PerPage != nil {
		query.Set("per_page", strconv.FormatInt(*r.PerPage, 10))
	}
	if r.Page != nil {
		query.Set("page", strconv.FormatInt(*r.Page, 10))
	}

	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/runs/%v/jobs", r.Owner, r.Repo, r.RunId),
		URLQuery:    query,
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *ListJobsForWorkflowRunReq) Rel(link string, resp *ListJobsForWorkflowRunResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
ListJobsForWorkflowRunResponseBody is a response body for ListJobsForWorkflowRun

https://developer.github.com/v3/actions/workflow-jobs/#list-jobs-for-a-workflow-run
*/
type ListJobsForWorkflowRunResponseBody struct {
	Jobs       []components.Job `json:"jobs,omitempty"`
	TotalCount int64            `json:"total_count,omitempty"`
}

/*
ListJobsForWorkflowRunResponse is a response for ListJobsForWorkflowRun

https://developer.github.com/v3/actions/workflow-jobs/#list-jobs-for-a-workflow-run
*/
type ListJobsForWorkflowRunResponse struct {
	httpResponse *http.Response
	Data         ListJobsForWorkflowRunResponseBody
}

// HTTPResponse returns the *http.Response
func (r *ListJobsForWorkflowRunResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *ListJobsForWorkflowRunResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
ListOrgSecrets performs requests for "actions/list-org-secrets"

List organization secrets.

  GET /orgs/{org}/actions/secrets

https://developer.github.com/v3/actions/secrets/#list-organization-secrets
*/
func ListOrgSecrets(ctx context.Context, req *ListOrgSecretsReq, opt ...requests.Option) (*ListOrgSecretsResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(ListOrgSecretsReq)
	}
	resp := &ListOrgSecretsResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
ListOrgSecrets performs requests for "actions/list-org-secrets"

List organization secrets.

  GET /orgs/{org}/actions/secrets

https://developer.github.com/v3/actions/secrets/#list-organization-secrets

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) ListOrgSecrets(ctx context.Context, req *ListOrgSecretsReq, opt ...requests.Option) (*ListOrgSecretsResponse, error) {
	return ListOrgSecrets(ctx, req, append(c, opt...)...)
}

/*
ListOrgSecretsReq is request data for Client.ListOrgSecrets

https://developer.github.com/v3/actions/secrets/#list-organization-secrets

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type ListOrgSecretsReq struct {
	_url string
	Org  string

	// Results per page (max 100)
	PerPage *int64

	// Page number of the results to fetch.
	Page *int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *ListOrgSecretsReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	query := url.Values{}
	if r.PerPage != nil {
		query.Set("per_page", strconv.FormatInt(*r.PerPage, 10))
	}
	if r.Page != nil {
		query.Set("page", strconv.FormatInt(*r.Page, 10))
	}

	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/orgs/%v/actions/secrets", r.Org),
		URLQuery:    query,
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *ListOrgSecretsReq) Rel(link string, resp *ListOrgSecretsResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
ListOrgSecretsResponseBody is a response body for ListOrgSecrets

https://developer.github.com/v3/actions/secrets/#list-organization-secrets
*/
type ListOrgSecretsResponseBody struct {
	Secrets    []components.OrganizationActionsSecret `json:"secrets,omitempty"`
	TotalCount int64                                  `json:"total_count,omitempty"`
}

/*
ListOrgSecretsResponse is a response for ListOrgSecrets

https://developer.github.com/v3/actions/secrets/#list-organization-secrets
*/
type ListOrgSecretsResponse struct {
	httpResponse *http.Response
	Data         ListOrgSecretsResponseBody
}

// HTTPResponse returns the *http.Response
func (r *ListOrgSecretsResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *ListOrgSecretsResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
ListRepoSecrets performs requests for "actions/list-repo-secrets"

List repository secrets.

  GET /repos/{owner}/{repo}/actions/secrets

https://developer.github.com/v3/actions/secrets/#list-repository-secrets
*/
func ListRepoSecrets(ctx context.Context, req *ListRepoSecretsReq, opt ...requests.Option) (*ListRepoSecretsResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(ListRepoSecretsReq)
	}
	resp := &ListRepoSecretsResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
ListRepoSecrets performs requests for "actions/list-repo-secrets"

List repository secrets.

  GET /repos/{owner}/{repo}/actions/secrets

https://developer.github.com/v3/actions/secrets/#list-repository-secrets

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) ListRepoSecrets(ctx context.Context, req *ListRepoSecretsReq, opt ...requests.Option) (*ListRepoSecretsResponse, error) {
	return ListRepoSecrets(ctx, req, append(c, opt...)...)
}

/*
ListRepoSecretsReq is request data for Client.ListRepoSecrets

https://developer.github.com/v3/actions/secrets/#list-repository-secrets

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type ListRepoSecretsReq struct {
	_url  string
	Owner string
	Repo  string

	// Results per page (max 100)
	PerPage *int64

	// Page number of the results to fetch.
	Page *int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *ListRepoSecretsReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	query := url.Values{}
	if r.PerPage != nil {
		query.Set("per_page", strconv.FormatInt(*r.PerPage, 10))
	}
	if r.Page != nil {
		query.Set("page", strconv.FormatInt(*r.Page, 10))
	}

	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/secrets", r.Owner, r.Repo),
		URLQuery:    query,
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *ListRepoSecretsReq) Rel(link string, resp *ListRepoSecretsResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
ListRepoSecretsResponseBody is a response body for ListRepoSecrets

https://developer.github.com/v3/actions/secrets/#list-repository-secrets
*/
type ListRepoSecretsResponseBody struct {
	Secrets    []components.ActionsSecret `json:"secrets,omitempty"`
	TotalCount int64                      `json:"total_count,omitempty"`
}

/*
ListRepoSecretsResponse is a response for ListRepoSecrets

https://developer.github.com/v3/actions/secrets/#list-repository-secrets
*/
type ListRepoSecretsResponse struct {
	httpResponse *http.Response
	Data         ListRepoSecretsResponseBody
}

// HTTPResponse returns the *http.Response
func (r *ListRepoSecretsResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *ListRepoSecretsResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
ListRepoWorkflows performs requests for "actions/list-repo-workflows"

List repository workflows.

  GET /repos/{owner}/{repo}/actions/workflows

https://developer.github.com/v3/actions/workflows/#list-repository-workflows
*/
func ListRepoWorkflows(ctx context.Context, req *ListRepoWorkflowsReq, opt ...requests.Option) (*ListRepoWorkflowsResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(ListRepoWorkflowsReq)
	}
	resp := &ListRepoWorkflowsResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
ListRepoWorkflows performs requests for "actions/list-repo-workflows"

List repository workflows.

  GET /repos/{owner}/{repo}/actions/workflows

https://developer.github.com/v3/actions/workflows/#list-repository-workflows

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) ListRepoWorkflows(ctx context.Context, req *ListRepoWorkflowsReq, opt ...requests.Option) (*ListRepoWorkflowsResponse, error) {
	return ListRepoWorkflows(ctx, req, append(c, opt...)...)
}

/*
ListRepoWorkflowsReq is request data for Client.ListRepoWorkflows

https://developer.github.com/v3/actions/workflows/#list-repository-workflows

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type ListRepoWorkflowsReq struct {
	_url  string
	Owner string
	Repo  string

	// Results per page (max 100)
	PerPage *int64

	// Page number of the results to fetch.
	Page *int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *ListRepoWorkflowsReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	query := url.Values{}
	if r.PerPage != nil {
		query.Set("per_page", strconv.FormatInt(*r.PerPage, 10))
	}
	if r.Page != nil {
		query.Set("page", strconv.FormatInt(*r.Page, 10))
	}

	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/workflows", r.Owner, r.Repo),
		URLQuery:    query,
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *ListRepoWorkflowsReq) Rel(link string, resp *ListRepoWorkflowsResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
ListRepoWorkflowsResponseBody is a response body for ListRepoWorkflows

https://developer.github.com/v3/actions/workflows/#list-repository-workflows
*/
type ListRepoWorkflowsResponseBody struct {
	TotalCount int64                 `json:"total_count,omitempty"`
	Workflows  []components.Workflow `json:"workflows,omitempty"`
}

/*
ListRepoWorkflowsResponse is a response for ListRepoWorkflows

https://developer.github.com/v3/actions/workflows/#list-repository-workflows
*/
type ListRepoWorkflowsResponse struct {
	httpResponse *http.Response
	Data         ListRepoWorkflowsResponseBody
}

// HTTPResponse returns the *http.Response
func (r *ListRepoWorkflowsResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *ListRepoWorkflowsResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
ListRunnerApplicationsForOrg performs requests for "actions/list-runner-applications-for-org"

List runner applications for an organization.

  GET /orgs/{org}/actions/runners/downloads

https://developer.github.com/v3/actions/self-hosted-runners/#list-runner-applications-for-an-organization
*/
func ListRunnerApplicationsForOrg(ctx context.Context, req *ListRunnerApplicationsForOrgReq, opt ...requests.Option) (*ListRunnerApplicationsForOrgResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(ListRunnerApplicationsForOrgReq)
	}
	resp := &ListRunnerApplicationsForOrgResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
ListRunnerApplicationsForOrg performs requests for "actions/list-runner-applications-for-org"

List runner applications for an organization.

  GET /orgs/{org}/actions/runners/downloads

https://developer.github.com/v3/actions/self-hosted-runners/#list-runner-applications-for-an-organization

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) ListRunnerApplicationsForOrg(ctx context.Context, req *ListRunnerApplicationsForOrgReq, opt ...requests.Option) (*ListRunnerApplicationsForOrgResponse, error) {
	return ListRunnerApplicationsForOrg(ctx, req, append(c, opt...)...)
}

/*
ListRunnerApplicationsForOrgReq is request data for Client.ListRunnerApplicationsForOrg

https://developer.github.com/v3/actions/self-hosted-runners/#list-runner-applications-for-an-organization

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type ListRunnerApplicationsForOrgReq struct {
	_url string
	Org  string
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *ListRunnerApplicationsForOrgReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/orgs/%v/actions/runners/downloads", r.Org),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *ListRunnerApplicationsForOrgReq) Rel(link string, resp *ListRunnerApplicationsForOrgResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
ListRunnerApplicationsForOrgResponse is a response for ListRunnerApplicationsForOrg

https://developer.github.com/v3/actions/self-hosted-runners/#list-runner-applications-for-an-organization
*/
type ListRunnerApplicationsForOrgResponse struct {
	httpResponse *http.Response
	Data         []components.RunnerApplication
}

// HTTPResponse returns the *http.Response
func (r *ListRunnerApplicationsForOrgResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *ListRunnerApplicationsForOrgResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
ListRunnerApplicationsForRepo performs requests for "actions/list-runner-applications-for-repo"

List runner applications for a repository.

  GET /repos/{owner}/{repo}/actions/runners/downloads

https://developer.github.com/v3/actions/self-hosted-runners/#list-runner-applications-for-a-repository
*/
func ListRunnerApplicationsForRepo(ctx context.Context, req *ListRunnerApplicationsForRepoReq, opt ...requests.Option) (*ListRunnerApplicationsForRepoResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(ListRunnerApplicationsForRepoReq)
	}
	resp := &ListRunnerApplicationsForRepoResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
ListRunnerApplicationsForRepo performs requests for "actions/list-runner-applications-for-repo"

List runner applications for a repository.

  GET /repos/{owner}/{repo}/actions/runners/downloads

https://developer.github.com/v3/actions/self-hosted-runners/#list-runner-applications-for-a-repository

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) ListRunnerApplicationsForRepo(ctx context.Context, req *ListRunnerApplicationsForRepoReq, opt ...requests.Option) (*ListRunnerApplicationsForRepoResponse, error) {
	return ListRunnerApplicationsForRepo(ctx, req, append(c, opt...)...)
}

/*
ListRunnerApplicationsForRepoReq is request data for Client.ListRunnerApplicationsForRepo

https://developer.github.com/v3/actions/self-hosted-runners/#list-runner-applications-for-a-repository

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type ListRunnerApplicationsForRepoReq struct {
	_url  string
	Owner string
	Repo  string
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *ListRunnerApplicationsForRepoReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/runners/downloads", r.Owner, r.Repo),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *ListRunnerApplicationsForRepoReq) Rel(link string, resp *ListRunnerApplicationsForRepoResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
ListRunnerApplicationsForRepoResponse is a response for ListRunnerApplicationsForRepo

https://developer.github.com/v3/actions/self-hosted-runners/#list-runner-applications-for-a-repository
*/
type ListRunnerApplicationsForRepoResponse struct {
	httpResponse *http.Response
	Data         []components.RunnerApplication
}

// HTTPResponse returns the *http.Response
func (r *ListRunnerApplicationsForRepoResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *ListRunnerApplicationsForRepoResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
ListSelectedReposForOrgSecret performs requests for "actions/list-selected-repos-for-org-secret"

List selected repositories for an organization secret.

  GET /orgs/{org}/actions/secrets/{secret_name}/repositories

https://developer.github.com/v3/actions/secrets/#list-selected-repositories-for-an-organization-secret
*/
func ListSelectedReposForOrgSecret(ctx context.Context, req *ListSelectedReposForOrgSecretReq, opt ...requests.Option) (*ListSelectedReposForOrgSecretResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(ListSelectedReposForOrgSecretReq)
	}
	resp := &ListSelectedReposForOrgSecretResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
ListSelectedReposForOrgSecret performs requests for "actions/list-selected-repos-for-org-secret"

List selected repositories for an organization secret.

  GET /orgs/{org}/actions/secrets/{secret_name}/repositories

https://developer.github.com/v3/actions/secrets/#list-selected-repositories-for-an-organization-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) ListSelectedReposForOrgSecret(ctx context.Context, req *ListSelectedReposForOrgSecretReq, opt ...requests.Option) (*ListSelectedReposForOrgSecretResponse, error) {
	return ListSelectedReposForOrgSecret(ctx, req, append(c, opt...)...)
}

/*
ListSelectedReposForOrgSecretReq is request data for Client.ListSelectedReposForOrgSecret

https://developer.github.com/v3/actions/secrets/#list-selected-repositories-for-an-organization-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type ListSelectedReposForOrgSecretReq struct {
	_url string
	Org  string

	// secret_name parameter
	SecretName string
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *ListSelectedReposForOrgSecretReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/orgs/%v/actions/secrets/%v/repositories", r.Org, r.SecretName),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *ListSelectedReposForOrgSecretReq) Rel(link string, resp *ListSelectedReposForOrgSecretResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
ListSelectedReposForOrgSecretResponseBody is a response body for ListSelectedReposForOrgSecret

https://developer.github.com/v3/actions/secrets/#list-selected-repositories-for-an-organization-secret
*/
type ListSelectedReposForOrgSecretResponseBody struct {
	Repositories []components.MinimalRepository `json:"repositories,omitempty"`
	TotalCount   int64                          `json:"total_count,omitempty"`
}

/*
ListSelectedReposForOrgSecretResponse is a response for ListSelectedReposForOrgSecret

https://developer.github.com/v3/actions/secrets/#list-selected-repositories-for-an-organization-secret
*/
type ListSelectedReposForOrgSecretResponse struct {
	httpResponse *http.Response
	Data         ListSelectedReposForOrgSecretResponseBody
}

// HTTPResponse returns the *http.Response
func (r *ListSelectedReposForOrgSecretResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *ListSelectedReposForOrgSecretResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
ListSelfHostedRunnersForOrg performs requests for "actions/list-self-hosted-runners-for-org"

List self-hosted runners for an organization.

  GET /orgs/{org}/actions/runners

https://developer.github.com/v3/actions/self-hosted-runners/#list-self-hosted-runners-for-an-organization
*/
func ListSelfHostedRunnersForOrg(ctx context.Context, req *ListSelfHostedRunnersForOrgReq, opt ...requests.Option) (*ListSelfHostedRunnersForOrgResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(ListSelfHostedRunnersForOrgReq)
	}
	resp := &ListSelfHostedRunnersForOrgResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
ListSelfHostedRunnersForOrg performs requests for "actions/list-self-hosted-runners-for-org"

List self-hosted runners for an organization.

  GET /orgs/{org}/actions/runners

https://developer.github.com/v3/actions/self-hosted-runners/#list-self-hosted-runners-for-an-organization

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) ListSelfHostedRunnersForOrg(ctx context.Context, req *ListSelfHostedRunnersForOrgReq, opt ...requests.Option) (*ListSelfHostedRunnersForOrgResponse, error) {
	return ListSelfHostedRunnersForOrg(ctx, req, append(c, opt...)...)
}

/*
ListSelfHostedRunnersForOrgReq is request data for Client.ListSelfHostedRunnersForOrg

https://developer.github.com/v3/actions/self-hosted-runners/#list-self-hosted-runners-for-an-organization

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type ListSelfHostedRunnersForOrgReq struct {
	_url string
	Org  string

	// Results per page (max 100)
	PerPage *int64

	// Page number of the results to fetch.
	Page *int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *ListSelfHostedRunnersForOrgReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	query := url.Values{}
	if r.PerPage != nil {
		query.Set("per_page", strconv.FormatInt(*r.PerPage, 10))
	}
	if r.Page != nil {
		query.Set("page", strconv.FormatInt(*r.Page, 10))
	}

	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/orgs/%v/actions/runners", r.Org),
		URLQuery:    query,
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *ListSelfHostedRunnersForOrgReq) Rel(link string, resp *ListSelfHostedRunnersForOrgResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
ListSelfHostedRunnersForOrgResponseBody is a response body for ListSelfHostedRunnersForOrg

https://developer.github.com/v3/actions/self-hosted-runners/#list-self-hosted-runners-for-an-organization
*/
type ListSelfHostedRunnersForOrgResponseBody struct {
	Runners    []components.Runner `json:"runners,omitempty"`
	TotalCount int64               `json:"total_count,omitempty"`
}

/*
ListSelfHostedRunnersForOrgResponse is a response for ListSelfHostedRunnersForOrg

https://developer.github.com/v3/actions/self-hosted-runners/#list-self-hosted-runners-for-an-organization
*/
type ListSelfHostedRunnersForOrgResponse struct {
	httpResponse *http.Response
	Data         ListSelfHostedRunnersForOrgResponseBody
}

// HTTPResponse returns the *http.Response
func (r *ListSelfHostedRunnersForOrgResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *ListSelfHostedRunnersForOrgResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
ListSelfHostedRunnersForRepo performs requests for "actions/list-self-hosted-runners-for-repo"

List self-hosted runners for a repository.

  GET /repos/{owner}/{repo}/actions/runners

https://developer.github.com/v3/actions/self-hosted-runners/#list-self-hosted-runners-for-a-repository
*/
func ListSelfHostedRunnersForRepo(ctx context.Context, req *ListSelfHostedRunnersForRepoReq, opt ...requests.Option) (*ListSelfHostedRunnersForRepoResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(ListSelfHostedRunnersForRepoReq)
	}
	resp := &ListSelfHostedRunnersForRepoResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
ListSelfHostedRunnersForRepo performs requests for "actions/list-self-hosted-runners-for-repo"

List self-hosted runners for a repository.

  GET /repos/{owner}/{repo}/actions/runners

https://developer.github.com/v3/actions/self-hosted-runners/#list-self-hosted-runners-for-a-repository

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) ListSelfHostedRunnersForRepo(ctx context.Context, req *ListSelfHostedRunnersForRepoReq, opt ...requests.Option) (*ListSelfHostedRunnersForRepoResponse, error) {
	return ListSelfHostedRunnersForRepo(ctx, req, append(c, opt...)...)
}

/*
ListSelfHostedRunnersForRepoReq is request data for Client.ListSelfHostedRunnersForRepo

https://developer.github.com/v3/actions/self-hosted-runners/#list-self-hosted-runners-for-a-repository

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type ListSelfHostedRunnersForRepoReq struct {
	_url  string
	Owner string
	Repo  string

	// Results per page (max 100)
	PerPage *int64

	// Page number of the results to fetch.
	Page *int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *ListSelfHostedRunnersForRepoReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	query := url.Values{}
	if r.PerPage != nil {
		query.Set("per_page", strconv.FormatInt(*r.PerPage, 10))
	}
	if r.Page != nil {
		query.Set("page", strconv.FormatInt(*r.Page, 10))
	}

	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/runners", r.Owner, r.Repo),
		URLQuery:    query,
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *ListSelfHostedRunnersForRepoReq) Rel(link string, resp *ListSelfHostedRunnersForRepoResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
ListSelfHostedRunnersForRepoResponseBody is a response body for ListSelfHostedRunnersForRepo

https://developer.github.com/v3/actions/self-hosted-runners/#list-self-hosted-runners-for-a-repository
*/
type ListSelfHostedRunnersForRepoResponseBody struct {
	Runners    []components.Runner `json:"runners,omitempty"`
	TotalCount int64               `json:"total_count,omitempty"`
}

/*
ListSelfHostedRunnersForRepoResponse is a response for ListSelfHostedRunnersForRepo

https://developer.github.com/v3/actions/self-hosted-runners/#list-self-hosted-runners-for-a-repository
*/
type ListSelfHostedRunnersForRepoResponse struct {
	httpResponse *http.Response
	Data         ListSelfHostedRunnersForRepoResponseBody
}

// HTTPResponse returns the *http.Response
func (r *ListSelfHostedRunnersForRepoResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *ListSelfHostedRunnersForRepoResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
ListWorkflowRunArtifacts performs requests for "actions/list-workflow-run-artifacts"

List workflow run artifacts.

  GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts

https://developer.github.com/v3/actions/artifacts/#list-workflow-run-artifacts
*/
func ListWorkflowRunArtifacts(ctx context.Context, req *ListWorkflowRunArtifactsReq, opt ...requests.Option) (*ListWorkflowRunArtifactsResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(ListWorkflowRunArtifactsReq)
	}
	resp := &ListWorkflowRunArtifactsResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
ListWorkflowRunArtifacts performs requests for "actions/list-workflow-run-artifacts"

List workflow run artifacts.

  GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts

https://developer.github.com/v3/actions/artifacts/#list-workflow-run-artifacts

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) ListWorkflowRunArtifacts(ctx context.Context, req *ListWorkflowRunArtifactsReq, opt ...requests.Option) (*ListWorkflowRunArtifactsResponse, error) {
	return ListWorkflowRunArtifacts(ctx, req, append(c, opt...)...)
}

/*
ListWorkflowRunArtifactsReq is request data for Client.ListWorkflowRunArtifacts

https://developer.github.com/v3/actions/artifacts/#list-workflow-run-artifacts

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type ListWorkflowRunArtifactsReq struct {
	_url  string
	Owner string
	Repo  string
	RunId int64

	// Results per page (max 100)
	PerPage *int64

	// Page number of the results to fetch.
	Page *int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *ListWorkflowRunArtifactsReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	query := url.Values{}
	if r.PerPage != nil {
		query.Set("per_page", strconv.FormatInt(*r.PerPage, 10))
	}
	if r.Page != nil {
		query.Set("page", strconv.FormatInt(*r.Page, 10))
	}

	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/runs/%v/artifacts", r.Owner, r.Repo, r.RunId),
		URLQuery:    query,
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *ListWorkflowRunArtifactsReq) Rel(link string, resp *ListWorkflowRunArtifactsResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
ListWorkflowRunArtifactsResponseBody is a response body for ListWorkflowRunArtifacts

https://developer.github.com/v3/actions/artifacts/#list-workflow-run-artifacts
*/
type ListWorkflowRunArtifactsResponseBody struct {
	Artifacts  []components.Artifact `json:"artifacts,omitempty"`
	TotalCount int64                 `json:"total_count,omitempty"`
}

/*
ListWorkflowRunArtifactsResponse is a response for ListWorkflowRunArtifacts

https://developer.github.com/v3/actions/artifacts/#list-workflow-run-artifacts
*/
type ListWorkflowRunArtifactsResponse struct {
	httpResponse *http.Response
	Data         ListWorkflowRunArtifactsResponseBody
}

// HTTPResponse returns the *http.Response
func (r *ListWorkflowRunArtifactsResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *ListWorkflowRunArtifactsResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
ListWorkflowRuns performs requests for "actions/list-workflow-runs"

List workflow runs.

  GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs

https://developer.github.com/v3/actions/workflow-runs/#list-workflow-runs
*/
func ListWorkflowRuns(ctx context.Context, req *ListWorkflowRunsReq, opt ...requests.Option) (*ListWorkflowRunsResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(ListWorkflowRunsReq)
	}
	resp := &ListWorkflowRunsResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
ListWorkflowRuns performs requests for "actions/list-workflow-runs"

List workflow runs.

  GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs

https://developer.github.com/v3/actions/workflow-runs/#list-workflow-runs

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) ListWorkflowRuns(ctx context.Context, req *ListWorkflowRunsReq, opt ...requests.Option) (*ListWorkflowRunsResponse, error) {
	return ListWorkflowRuns(ctx, req, append(c, opt...)...)
}

/*
ListWorkflowRunsReq is request data for Client.ListWorkflowRuns

https://developer.github.com/v3/actions/workflow-runs/#list-workflow-runs

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type ListWorkflowRunsReq struct {
	_url       string
	Owner      string
	Repo       string
	WorkflowId int64

	/*
	Returns someone's workflow runs. Use the login for the user who created the
	`push` associated with the check suite or workflow run.
	*/
	Actor *string

	/*
	Returns workflow runs associated with a branch. Use the name of the branch of
	the `push`.
	*/
	Branch *string

	/*
	Returns workflow run triggered by the event you specify. For example, `push`,
	`pull_request` or `issue`. For more information, see "[Events that trigger
	workflows](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/events-that-trigger-workflows)."
	*/
	Event *string

	/*
	Returns workflow runs associated with the check run `status` or `conclusion` you
	specify. For example, a conclusion can be `success` or a status can be
	`completed`. For more information, see the `status` and `conclusion` options
	available in "[Create a check
	run](https://developer.github.com/v3/checks/runs/#create-a-check-run)."
	*/
	Status *string

	// Results per page (max 100)
	PerPage *int64

	// Page number of the results to fetch.
	Page *int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *ListWorkflowRunsReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	query := url.Values{}
	if r.Actor != nil {
		query.Set("actor", *r.Actor)
	}
	if r.Branch != nil {
		query.Set("branch", *r.Branch)
	}
	if r.Event != nil {
		query.Set("event", *r.Event)
	}
	if r.Status != nil {
		query.Set("status", *r.Status)
	}
	if r.PerPage != nil {
		query.Set("per_page", strconv.FormatInt(*r.PerPage, 10))
	}
	if r.Page != nil {
		query.Set("page", strconv.FormatInt(*r.Page, 10))
	}

	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/workflows/%v/runs", r.Owner, r.Repo, r.WorkflowId),
		URLQuery:    query,
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *ListWorkflowRunsReq) Rel(link string, resp *ListWorkflowRunsResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
ListWorkflowRunsResponseBody is a response body for ListWorkflowRuns

https://developer.github.com/v3/actions/workflow-runs/#list-workflow-runs
*/
type ListWorkflowRunsResponseBody struct {
	TotalCount   int64                    `json:"total_count,omitempty"`
	WorkflowRuns []components.WorkflowRun `json:"workflow_runs,omitempty"`
}

/*
ListWorkflowRunsResponse is a response for ListWorkflowRuns

https://developer.github.com/v3/actions/workflow-runs/#list-workflow-runs
*/
type ListWorkflowRunsResponse struct {
	httpResponse *http.Response
	Data         ListWorkflowRunsResponseBody
}

// HTTPResponse returns the *http.Response
func (r *ListWorkflowRunsResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *ListWorkflowRunsResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
ListWorkflowRunsForRepo performs requests for "actions/list-workflow-runs-for-repo"

List workflow runs for a repository.

  GET /repos/{owner}/{repo}/actions/runs

https://developer.github.com/v3/actions/workflow-runs/#list-workflow-runs-for-a-repository
*/
func ListWorkflowRunsForRepo(ctx context.Context, req *ListWorkflowRunsForRepoReq, opt ...requests.Option) (*ListWorkflowRunsForRepoResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(ListWorkflowRunsForRepoReq)
	}
	resp := &ListWorkflowRunsForRepoResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
ListWorkflowRunsForRepo performs requests for "actions/list-workflow-runs-for-repo"

List workflow runs for a repository.

  GET /repos/{owner}/{repo}/actions/runs

https://developer.github.com/v3/actions/workflow-runs/#list-workflow-runs-for-a-repository

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) ListWorkflowRunsForRepo(ctx context.Context, req *ListWorkflowRunsForRepoReq, opt ...requests.Option) (*ListWorkflowRunsForRepoResponse, error) {
	return ListWorkflowRunsForRepo(ctx, req, append(c, opt...)...)
}

/*
ListWorkflowRunsForRepoReq is request data for Client.ListWorkflowRunsForRepo

https://developer.github.com/v3/actions/workflow-runs/#list-workflow-runs-for-a-repository

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type ListWorkflowRunsForRepoReq struct {
	_url  string
	Owner string
	Repo  string

	/*
	Returns someone's workflow runs. Use the login for the user who created the
	`push` associated with the check suite or workflow run.
	*/
	Actor *string

	/*
	Returns workflow runs associated with a branch. Use the name of the branch of
	the `push`.
	*/
	Branch *string

	/*
	Returns workflow run triggered by the event you specify. For example, `push`,
	`pull_request` or `issue`. For more information, see "[Events that trigger
	workflows](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/events-that-trigger-workflows)."
	*/
	Event *string

	/*
	Returns workflow runs associated with the check run `status` or `conclusion` you
	specify. For example, a conclusion can be `success` or a status can be
	`completed`. For more information, see the `status` and `conclusion` options
	available in "[Create a check
	run](https://developer.github.com/v3/checks/runs/#create-a-check-run)."
	*/
	Status *string

	// Results per page (max 100)
	PerPage *int64

	// Page number of the results to fetch.
	Page *int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *ListWorkflowRunsForRepoReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	query := url.Values{}
	if r.Actor != nil {
		query.Set("actor", *r.Actor)
	}
	if r.Branch != nil {
		query.Set("branch", *r.Branch)
	}
	if r.Event != nil {
		query.Set("event", *r.Event)
	}
	if r.Status != nil {
		query.Set("status", *r.Status)
	}
	if r.PerPage != nil {
		query.Set("per_page", strconv.FormatInt(*r.PerPage, 10))
	}
	if r.Page != nil {
		query.Set("page", strconv.FormatInt(*r.Page, 10))
	}

	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"accept": internal.String("application/json")},
		Method:      "GET",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/runs", r.Owner, r.Repo),
		URLQuery:    query,
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *ListWorkflowRunsForRepoReq) Rel(link string, resp *ListWorkflowRunsForRepoResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
ListWorkflowRunsForRepoResponseBody is a response body for ListWorkflowRunsForRepo

https://developer.github.com/v3/actions/workflow-runs/#list-workflow-runs-for-a-repository
*/
type ListWorkflowRunsForRepoResponseBody struct {
	TotalCount   int64                    `json:"total_count,omitempty"`
	WorkflowRuns []components.WorkflowRun `json:"workflow_runs,omitempty"`
}

/*
ListWorkflowRunsForRepoResponse is a response for ListWorkflowRunsForRepo

https://developer.github.com/v3/actions/workflow-runs/#list-workflow-runs-for-a-repository
*/
type ListWorkflowRunsForRepoResponse struct {
	httpResponse *http.Response
	Data         ListWorkflowRunsForRepoResponseBody
}

// HTTPResponse returns the *http.Response
func (r *ListWorkflowRunsForRepoResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *ListWorkflowRunsForRepoResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if internal.IntInSlice(resp.StatusCode, []int{200}) {
		err = internal.UnmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}

/*
ReRunWorkflow performs requests for "actions/re-run-workflow"

Re-run a workflow.

  POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun

https://developer.github.com/v3/actions/workflow-runs/#re-run-a-workflow
*/
func ReRunWorkflow(ctx context.Context, req *ReRunWorkflowReq, opt ...requests.Option) (*ReRunWorkflowResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(ReRunWorkflowReq)
	}
	resp := &ReRunWorkflowResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
ReRunWorkflow performs requests for "actions/re-run-workflow"

Re-run a workflow.

  POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun

https://developer.github.com/v3/actions/workflow-runs/#re-run-a-workflow

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) ReRunWorkflow(ctx context.Context, req *ReRunWorkflowReq, opt ...requests.Option) (*ReRunWorkflowResponse, error) {
	return ReRunWorkflow(ctx, req, append(c, opt...)...)
}

/*
ReRunWorkflowReq is request data for Client.ReRunWorkflow

https://developer.github.com/v3/actions/workflow-runs/#re-run-a-workflow

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type ReRunWorkflowReq struct {
	_url  string
	Owner string
	Repo  string
	RunId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *ReRunWorkflowReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		Method:      "POST",
		Options:     opt,
		URLPath:     fmt.Sprintf("/repos/%v/%v/actions/runs/%v/rerun", r.Owner, r.Repo, r.RunId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *ReRunWorkflowReq) Rel(link string, resp *ReRunWorkflowResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
ReRunWorkflowResponse is a response for ReRunWorkflow

https://developer.github.com/v3/actions/workflow-runs/#re-run-a-workflow
*/
type ReRunWorkflowResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *ReRunWorkflowResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *ReRunWorkflowResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{201})
	if err != nil {
		return err
	}
	return nil
}

/*
RemoveSelectedRepoFromOrgSecret performs requests for "actions/remove-selected-repo-from-org-secret"

Remove selected repository from an organization secret.

  DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}

https://developer.github.com/v3/actions/secrets/#remove-selected-repository-from-an-organization-secret
*/
func RemoveSelectedRepoFromOrgSecret(ctx context.Context, req *RemoveSelectedRepoFromOrgSecretReq, opt ...requests.Option) (*RemoveSelectedRepoFromOrgSecretResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(RemoveSelectedRepoFromOrgSecretReq)
	}
	resp := &RemoveSelectedRepoFromOrgSecretResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
RemoveSelectedRepoFromOrgSecret performs requests for "actions/remove-selected-repo-from-org-secret"

Remove selected repository from an organization secret.

  DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}

https://developer.github.com/v3/actions/secrets/#remove-selected-repository-from-an-organization-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) RemoveSelectedRepoFromOrgSecret(ctx context.Context, req *RemoveSelectedRepoFromOrgSecretReq, opt ...requests.Option) (*RemoveSelectedRepoFromOrgSecretResponse, error) {
	return RemoveSelectedRepoFromOrgSecret(ctx, req, append(c, opt...)...)
}

/*
RemoveSelectedRepoFromOrgSecretReq is request data for Client.RemoveSelectedRepoFromOrgSecret

https://developer.github.com/v3/actions/secrets/#remove-selected-repository-from-an-organization-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type RemoveSelectedRepoFromOrgSecretReq struct {
	_url string
	Org  string

	// secret_name parameter
	SecretName string

	// repository_id parameter
	RepositoryId int64
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *RemoveSelectedRepoFromOrgSecretReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		ExplicitURL: r._url,
		Method:      "DELETE",
		Options:     opt,
		URLPath:     fmt.Sprintf("/orgs/%v/actions/secrets/%v/repositories/%v", r.Org, r.SecretName, r.RepositoryId),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *RemoveSelectedRepoFromOrgSecretReq) Rel(link string, resp *RemoveSelectedRepoFromOrgSecretResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
RemoveSelectedRepoFromOrgSecretResponse is a response for RemoveSelectedRepoFromOrgSecret

https://developer.github.com/v3/actions/secrets/#remove-selected-repository-from-an-organization-secret
*/
type RemoveSelectedRepoFromOrgSecretResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *RemoveSelectedRepoFromOrgSecretResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *RemoveSelectedRepoFromOrgSecretResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{204})
	if err != nil {
		return err
	}
	return nil
}

/*
SetSelectedReposForOrgSecret performs requests for "actions/set-selected-repos-for-org-secret"

Set selected repositories for an organization secret.

  PUT /orgs/{org}/actions/secrets/{secret_name}/repositories

https://developer.github.com/v3/actions/secrets/#set-selected-repositories-for-an-organization-secret
*/
func SetSelectedReposForOrgSecret(ctx context.Context, req *SetSelectedReposForOrgSecretReq, opt ...requests.Option) (*SetSelectedReposForOrgSecretResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(SetSelectedReposForOrgSecretReq)
	}
	resp := &SetSelectedReposForOrgSecretResponse{}

	httpReq, err := req.HTTPRequest(ctx, opt...)
	if err != nil {
		return nil, err
	}

	r, err := opts.HttpClient().Do(httpReq)
	if err != nil {
		return nil, err
	}

	err = resp.ReadResponse(r)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

/*
SetSelectedReposForOrgSecret performs requests for "actions/set-selected-repos-for-org-secret"

Set selected repositories for an organization secret.

  PUT /orgs/{org}/actions/secrets/{secret_name}/repositories

https://developer.github.com/v3/actions/secrets/#set-selected-repositories-for-an-organization-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
func (c Client) SetSelectedReposForOrgSecret(ctx context.Context, req *SetSelectedReposForOrgSecretReq, opt ...requests.Option) (*SetSelectedReposForOrgSecretResponse, error) {
	return SetSelectedReposForOrgSecret(ctx, req, append(c, opt...)...)
}

/*
SetSelectedReposForOrgSecretReq is request data for Client.SetSelectedReposForOrgSecret

https://developer.github.com/v3/actions/secrets/#set-selected-repositories-for-an-organization-secret

Non-nil errors will have the type *requests.RequestError, octo.ResponseError or url.Error.
*/
type SetSelectedReposForOrgSecretReq struct {
	_url string
	Org  string

	// secret_name parameter
	SecretName  string
	RequestBody SetSelectedReposForOrgSecretReqBody
}

// HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
func (r *SetSelectedReposForOrgSecretReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return internal.BuildHTTPRequest(ctx, internal.BuildHTTPRequestOptions{
		Body:        r.RequestBody,
		ExplicitURL: r._url,
		HeaderVals:  map[string]*string{"content-type": internal.String("application/json")},
		Method:      "PUT",
		Options:     opt,
		URLPath:     fmt.Sprintf("/orgs/%v/actions/secrets/%v/repositories", r.Org, r.SecretName),
	})
}

/*
Rel updates this request to point to a relative link from resp. Returns false if
the link does not exist. Handy for paging.
*/
func (r *SetSelectedReposForOrgSecretReq) Rel(link string, resp *SetSelectedReposForOrgSecretResponse) bool {
	u := internal.RelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}

/*
SetSelectedReposForOrgSecretReqBody is a request body for actions/set-selected-repos-for-org-secret

https://developer.github.com/v3/actions/secrets/#set-selected-repositories-for-an-organization-secret
*/
type SetSelectedReposForOrgSecretReqBody struct {

	/*
	An array of repository ids that can access the organization secret. You can only
	provide a list of repository ids when the `visibility` is set to `selected`. You
	can add and remove individual repositories using the [Set selected repositories
	for an organization
	secret](https://developer.github.com/v3/actions/secrets/#set-selected-repositories-for-an-organization-secret)
	and [Remove selected repository from an organization
	secret](https://developer.github.com/v3/actions/secrets/#remove-selected-repository-from-an-organization-secret)
	endpoints.
	*/
	SelectedRepositoryIds []int64 `json:"selected_repository_ids,omitempty"`
}

/*
SetSelectedReposForOrgSecretResponse is a response for SetSelectedReposForOrgSecret

https://developer.github.com/v3/actions/secrets/#set-selected-repositories-for-an-organization-secret
*/
type SetSelectedReposForOrgSecretResponse struct {
	httpResponse *http.Response
}

// HTTPResponse returns the *http.Response
func (r *SetSelectedReposForOrgSecretResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}

// ReadResponse reads an *http.Response. Non-nil errors will have the type octo.ResponseError.
func (r *SetSelectedReposForOrgSecretResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := internal.ResponseErrorCheck(resp, []int{204})
	if err != nil {
		return err
	}
	return nil
}