func (r *RemoveRestrictionsForRepoReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return buildHTTPRequest(ctx, buildHTTPRequestOptions{
		AllPreviews:      []string{"sombra"},
		ExplicitURL:      r._url,
		Method:           "DELETE",
		Options:          opt,
		Previews:         map[string]bool{"sombra": r.SombraPreview},
		RequiredPreviews: []string{"sombra"},
		URLPath:          fmt.Sprintf("/repos/%v/%v/interaction-limits", r.Owner, r.Repo),
	})
}
HTTPRequest builds an *http.Request. Non-nil errors will have the type *requests.RequestError.
package interactions
import (
	"context"
	"fmt"
	components "github.com/willabides/octo-go/components"
	requests "github.com/willabides/octo-go/requests"
	"net/http"
)
func GetRestrictionsForOrg(ctx context.Context, req *GetRestrictionsForOrgReq, opt ...requests.Option) (*GetRestrictionsForOrgResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(GetRestrictionsForOrgReq)
	}
	resp := &GetRestrictionsForOrgResponse{}
	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
}
func (c Client) GetRestrictionsForOrg(ctx context.Context, req *GetRestrictionsForOrgReq, opt ...requests.Option) (*GetRestrictionsForOrgResponse, error) {
	return GetRestrictionsForOrg(ctx, req, append(c, opt...)...)
}
type GetRestrictionsForOrgReq struct {
	_url string
	Org  string
	SombraPreview bool
}
func (r *GetRestrictionsForOrgReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return buildHTTPRequest(ctx, buildHTTPRequestOptions{
		AllPreviews:      []string{"sombra"},
		ExplicitURL:      r._url,
		HeaderVals:       map[string]*string{"accept": strPtr("application/json")},
		Method:           "GET",
		Options:          opt,
		Previews:         map[string]bool{"sombra": r.SombraPreview},
		RequiredPreviews: []string{"sombra"},
		URLPath:          fmt.Sprintf("/orgs/%v/interaction-limits", r.Org),
	})
}
func (r *GetRestrictionsForOrgReq) Rel(link string, resp *GetRestrictionsForOrgResponse) bool {
	u := getRelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}
type GetRestrictionsForOrgResponse struct {
	httpResponse *http.Response
	Data         components.InteractionLimit
}
func (r *GetRestrictionsForOrgResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}
func (r *GetRestrictionsForOrgResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := responseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if intInSlice(resp.StatusCode, []int{200}) {
		err = unmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}
func GetRestrictionsForRepo(ctx context.Context, req *GetRestrictionsForRepoReq, opt ...requests.Option) (*GetRestrictionsForRepoResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(GetRestrictionsForRepoReq)
	}
	resp := &GetRestrictionsForRepoResponse{}
	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
}
func (c Client) GetRestrictionsForRepo(ctx context.Context, req *GetRestrictionsForRepoReq, opt ...requests.Option) (*GetRestrictionsForRepoResponse, error) {
	return GetRestrictionsForRepo(ctx, req, append(c, opt...)...)
}
type GetRestrictionsForRepoReq struct {
	_url  string
	Owner string
	Repo  string
	SombraPreview bool
}
func (r *GetRestrictionsForRepoReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return buildHTTPRequest(ctx, buildHTTPRequestOptions{
		AllPreviews:      []string{"sombra"},
		ExplicitURL:      r._url,
		HeaderVals:       map[string]*string{"accept": strPtr("application/json")},
		Method:           "GET",
		Options:          opt,
		Previews:         map[string]bool{"sombra": r.SombraPreview},
		RequiredPreviews: []string{"sombra"},
		URLPath:          fmt.Sprintf("/repos/%v/%v/interaction-limits", r.Owner, r.Repo),
	})
}
func (r *GetRestrictionsForRepoReq) Rel(link string, resp *GetRestrictionsForRepoResponse) bool {
	u := getRelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}
type GetRestrictionsForRepoResponse struct {
	httpResponse *http.Response
	Data         components.InteractionLimit
}
func (r *GetRestrictionsForRepoResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}
func (r *GetRestrictionsForRepoResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := responseErrorCheck(resp, []int{200})
	if err != nil {
		return err
	}
	if intInSlice(resp.StatusCode, []int{200}) {
		err = unmarshalResponseBody(resp, &r.Data)
		if err != nil {
			return err
		}
	}
	return nil
}
func RemoveRestrictionsForOrg(ctx context.Context, req *RemoveRestrictionsForOrgReq, opt ...requests.Option) (*RemoveRestrictionsForOrgResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(RemoveRestrictionsForOrgReq)
	}
	resp := &RemoveRestrictionsForOrgResponse{}
	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
}
func (c Client) RemoveRestrictionsForOrg(ctx context.Context, req *RemoveRestrictionsForOrgReq, opt ...requests.Option) (*RemoveRestrictionsForOrgResponse, error) {
	return RemoveRestrictionsForOrg(ctx, req, append(c, opt...)...)
}
type RemoveRestrictionsForOrgReq struct {
	_url string
	Org  string
	SombraPreview bool
}
func (r *RemoveRestrictionsForOrgReq) HTTPRequest(ctx context.Context, opt ...requests.Option) (*http.Request, error) {
	return buildHTTPRequest(ctx, buildHTTPRequestOptions{
		AllPreviews:      []string{"sombra"},
		ExplicitURL:      r._url,
		Method:           "DELETE",
		Options:          opt,
		Previews:         map[string]bool{"sombra": r.SombraPreview},
		RequiredPreviews: []string{"sombra"},
		URLPath:          fmt.Sprintf("/orgs/%v/interaction-limits", r.Org),
	})
}
func (r *RemoveRestrictionsForOrgReq) Rel(link string, resp *RemoveRestrictionsForOrgResponse) bool {
	u := getRelLink(resp.HTTPResponse(), link)
	if u == "" {
		return false
	}
	r._url = u
	return true
}
type RemoveRestrictionsForOrgResponse struct {
	httpResponse *http.Response
}
func (r *RemoveRestrictionsForOrgResponse) HTTPResponse() *http.Response {
	return r.httpResponse
}
func (r *RemoveRestrictionsForOrgResponse) ReadResponse(resp *http.Response) error {
	r.httpResponse = resp
	err := responseErrorCheck(resp, []int{204})
	if err != nil {
		return err
	}
	return nil
}
func RemoveRestrictionsForRepo(ctx context.Context, req *RemoveRestrictionsForRepoReq, opt ...requests.Option) (*RemoveRestrictionsForRepoResponse, error) {
	opts := requests.BuildOptions(opt...)
	if req == nil {
		req = new(RemoveRestrictionsForRepoReq)
	}
	resp := &RemoveRestrictionsForRepoResponse{}
	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
}
func (c Client) RemoveRestrictionsForRepo(ctx context.Context, req *RemoveRestrictionsForRepoReq, opt ...requests.Option) (*RemoveRestrictionsForRepoResponse, error) {
	return RemoveRestrictionsForRepo(ctx, req, append(c, opt...)...)
}
type RemoveRestrictionsForRepoReq struct {
	_url  string
	Owner string
	Repo  string
	SombraPreview bool
}