package github

/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.2.40
 * apibuilder 0.15.11 app.apibuilder.io/flow/github/0.2.40/go_1_5_client
 */

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"html"
	"io"
	"net/http"
	"net/url"
	"strconv"
	"strings"
)

const BaseUrl = "https://api.github.com"
const UserAgent = "apibuilder 0.15.11 app.apibuilder.io/flow/github/0.2.40/go_1_5_client"
const Version = "0.2.40"
const VersionMajor = 0

type Client struct {
	HttpClient *http.Client
	Username   string
	Password   string
	BaseUrl    string
}

type ClientRequestBody struct {
	contentType string
	bytes       io.Reader
}

type ContentsType string

const (
	ContentsTypeFile ContentsType  = "file"
	ContentsTypeDir                = "dir"
	ContentsTypeSymlink            = "symlink"
	ContentsTypeSubmodule          = "submodule"
	ContentsTypeUNDEFINED          = "UNDEFINED"
)

func ContentsTypeFromString(value string) ContentsType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "file":
		return ContentsTypeFile
	case "dir":
		return ContentsTypeDir
	case "symlink":
		return ContentsTypeSymlink
	case "submodule":
		return ContentsTypeSubmodule
	default:
		return ContentsTypeUNDEFINED
	}
}

type Encoding string

const (
	EncodingBase64 Encoding  = "base64"
	EncodingUtf8             = "utf-8"
	EncodingUNDEFINED        = "UNDEFINED"
)

func EncodingFromString(value string) Encoding {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "base64":
		return EncodingBase64
	case "utf-8":
		return EncodingUtf8
	default:
		return EncodingUNDEFINED
	}
}

type HookEvent string

const (
	HookEventPush HookEvent  = "push"
	HookEventPullRequest     = "pull_request"
	HookEventUNDEFINED       = "UNDEFINED"
)

func HookEventFromString(value string) HookEvent {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "push":
		return HookEventPush
	case "pull_request":
		return HookEventPullRequest
	default:
		return HookEventUNDEFINED
	}
}

type NodeType string

const (
	NodeTypeBlob NodeType  = "blob"
	NodeTypeTree           = "tree"
	NodeTypeCommit         = "commit"
	NodeTypeUNDEFINED      = "UNDEFINED"
)

func NodeTypeFromString(value string) NodeType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "blob":
		return NodeTypeBlob
	case "tree":
		return NodeTypeTree
	case "commit":
		return NodeTypeCommit
	default:
		return NodeTypeUNDEFINED
	}
}

type OwnerType string

const (
	OwnerTypeUser OwnerType  = "User"
	OwnerTypeUNDEFINED       = "UNDEFINED"
)

func OwnerTypeFromString(value string) OwnerType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "user":
		return OwnerTypeUser
	default:
		return OwnerTypeUNDEFINED
	}
}

type Visibility string

const (
	VisibilityAll Visibility  = "all"
	VisibilityPublic          = "public"
	VisibilityPrivate         = "private"
	VisibilityUNDEFINED       = "UNDEFINED"
)

func VisibilityFromString(value string) Visibility {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "all":
		return VisibilityAll
	case "public":
		return VisibilityPublic
	case "private":
		return VisibilityPrivate
	default:
		return VisibilityUNDEFINED
	}
}

type Blob struct {
	Content  string   `json:"content"`
	Encoding Encoding `json:"encoding"`
	Url      string   `json:"url"`
	Sha      string   `json:"sha"`
	Size     int64    `json:"size"`
}

func BlobFromMap(data interface{}) Blob {
	b, err := json.Marshal(data)
	if err == nil {
		return BlobFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func BlobFromJson(bytes io.Reader) Blob {
	var blob Blob
	json.NewDecoder(bytes).Decode(&blob)
	return blob
}

type BlobCreated struct {
	Url string `json:"url"`
	Sha string `json:"sha"`
}

func BlobCreatedFromMap(data interface{}) BlobCreated {
	b, err := json.Marshal(data)
	if err == nil {
		return BlobCreatedFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func BlobCreatedFromJson(bytes io.Reader) BlobCreated {
	var blobCreated BlobCreated
	json.NewDecoder(bytes).Decode(&blobCreated)
	return blobCreated
}

type BlobForm struct {
	Content  string   `json:"content"`
	Encoding Encoding `json:"encoding"`
}

func BlobFormFromMap(data interface{}) BlobForm {
	b, err := json.Marshal(data)
	if err == nil {
		return BlobFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func BlobFormFromJson(bytes io.Reader) BlobForm {
	var blobForm BlobForm
	json.NewDecoder(bytes).Decode(&blobForm)
	return blobForm
}

type Commit struct {
	Sha       string          `json:"sha"`
	Url       string          `json:"url"`
	HtmlUrl   string          `json:"html_url"`
	Author    Person          `json:"author"`
	Committer Person          `json:"committer"`
	Tree      TreeSummary     `json:"tree"`
	Message   string          `json:"message"`
	Parents   []CommitSummary `json:"parents"`
}

func CommitFromMap(data interface{}) Commit {
	b, err := json.Marshal(data)
	if err == nil {
		return CommitFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func CommitFromJson(bytes io.Reader) Commit {
	var commit Commit
	json.NewDecoder(bytes).Decode(&commit)
	return commit
}

type CommitForm struct {
	Message   string   `json:"message"`
	Tree      string   `json:"tree"`
	Parents   []string `json:"parents"`
	Author    Person   `json:"author"`
	Committer Person   `json:"committer"`
}

func CommitFormFromMap(data interface{}) CommitForm {
	b, err := json.Marshal(data)
	if err == nil {
		return CommitFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func CommitFormFromJson(bytes io.Reader) CommitForm {
	var commitForm CommitForm
	json.NewDecoder(bytes).Decode(&commitForm)
	return commitForm
}

type CommitResponse struct {
	Sha       string        `json:"sha"`
	Url       string        `json:"url"`
	Author    Person        `json:"author"`
	Committer Person        `json:"committer"`
	Message   string        `json:"message"`
	Tree      TreeSummary   `json:"tree"`
	Parents   []TreeSummary `json:"parents"`
}

func CommitResponseFromMap(data interface{}) CommitResponse {
	b, err := json.Marshal(data)
	if err == nil {
		return CommitResponseFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func CommitResponseFromJson(bytes io.Reader) CommitResponse {
	var commitResponse CommitResponse
	json.NewDecoder(bytes).Decode(&commitResponse)
	return commitResponse
}

type CommitSummary struct {
	Sha string `json:"sha"`
	Url string `json:"url"`
}

func CommitSummaryFromMap(data interface{}) CommitSummary {
	b, err := json.Marshal(data)
	if err == nil {
		return CommitSummaryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func CommitSummaryFromJson(bytes io.Reader) CommitSummary {
	var commitSummary CommitSummary
	json.NewDecoder(bytes).Decode(&commitSummary)
	return commitSummary
}

type Contents struct {
	Type        ContentsType `json:"type"`
	Encoding    Encoding     `json:"encoding"`
	Size        int64        `json:"size"`
	Name        string       `json:"name"`
	Path        string       `json:"path"`
	Content     string       `json:"content,omitempty"`
	Sha         string       `json:"sha"`
	Url         string       `json:"url"`
	GitUrl      string       `json:"git_url"`
	HtmlUrl     string       `json:"html_url"`
	DownloadUrl string       `json:"download_url"`
}

func ContentsFromMap(data interface{}) Contents {
	b, err := json.Marshal(data)
	if err == nil {
		return ContentsFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ContentsFromJson(bytes io.Reader) Contents {
	var contents Contents
	json.NewDecoder(bytes).Decode(&contents)
	return contents
}

type CreateTreeForm struct {
	BaseTree string     `json:"base_tree"`
	Tree     []TreeForm `json:"tree"`
}

func CreateTreeFormFromMap(data interface{}) CreateTreeForm {
	b, err := json.Marshal(data)
	if err == nil {
		return CreateTreeFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func CreateTreeFormFromJson(bytes io.Reader) CreateTreeForm {
	var createTreeForm CreateTreeForm
	json.NewDecoder(bytes).Decode(&createTreeForm)
	return createTreeForm
}

type CreateTreeResponse struct {
	Sha        string `json:"sha"`
	Url        string `json:"url"`
	TreeResult Tree   `json:"tree_result"`
}

func CreateTreeResponseFromMap(data interface{}) CreateTreeResponse {
	b, err := json.Marshal(data)
	if err == nil {
		return CreateTreeResponseFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func CreateTreeResponseFromJson(bytes io.Reader) CreateTreeResponse {
	var createTreeResponse CreateTreeResponse
	json.NewDecoder(bytes).Decode(&createTreeResponse)
	return createTreeResponse
}

type Error struct {
	Resource string `json:"resource"`
	Field    string `json:"field"`
	Code     string `json:"code"`
}

func ErrorFromMap(data interface{}) Error {
	b, err := json.Marshal(data)
	if err == nil {
		return ErrorFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ErrorFromJson(bytes io.Reader) Error {
	var error_ Error
	json.NewDecoder(bytes).Decode(&error_)
	return error_
}

type GithubObject struct {
	Type string `json:"type"`
	Sha  string `json:"sha"`
	Url  string `json:"url"`
}

func GithubObjectFromMap(data interface{}) GithubObject {
	b, err := json.Marshal(data)
	if err == nil {
		return GithubObjectFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func GithubObjectFromJson(bytes io.Reader) GithubObject {
	var githubObject GithubObject
	json.NewDecoder(bytes).Decode(&githubObject)
	return githubObject
}

/**
 * See https://developer.github.com/v3/repos/hooks/#create-a-hook
 */
type Hook struct {
	Id        int64       `json:"id"`
	Url       string      `json:"url"`
	TestUrl   string      `json:"test_url"`
	PingUrl   string      `json:"ping_url"`
	Name      string      `json:"name"`
	Events    []HookEvent `json:"events"`
	Active    string      `json:"active"`
	Config    HookConfig  `json:"config"`
	UpdatedAt string      `json:"updated_at"`
	CreatedAt string      `json:"created_at"`
}

func HookFromMap(data interface{}) Hook {
	b, err := json.Marshal(data)
	if err == nil {
		return HookFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func HookFromJson(bytes io.Reader) Hook {
	var hook Hook
	json.NewDecoder(bytes).Decode(&hook)
	return hook
}

type HookConfig struct {
	Url         string `json:"url,omitempty"`
	ContentType string `json:"content_type,omitempty"`
}

func HookConfigFromMap(data interface{}) HookConfig {
	b, err := json.Marshal(data)
	if err == nil {
		return HookConfigFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func HookConfigFromJson(bytes io.Reader) HookConfig {
	var hookConfig HookConfig
	json.NewDecoder(bytes).Decode(&hookConfig)
	return hookConfig
}

type HookForm struct {
	Name   string      `json:"name"`
	Config HookConfig  `json:"config"`
	Events []HookEvent `json:"events"`
	Active string      `json:"active"`
}

func HookFormFromMap(data interface{}) HookForm {
	b, err := json.Marshal(data)
	if err == nil {
		return HookFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func HookFormFromJson(bytes io.Reader) HookForm {
	var hookForm HookForm
	json.NewDecoder(bytes).Decode(&hookForm)
	return hookForm
}

type Node struct {
	Path string   `json:"path"`
	Mode string   `json:"mode"`
	Type NodeType `json:"type"`
	Size int64    `json:"size"`
	Sha  string   `json:"sha"`
	Url  string   `json:"url"`
}

func NodeFromMap(data interface{}) Node {
	b, err := json.Marshal(data)
	if err == nil {
		return NodeFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func NodeFromJson(bytes io.Reader) Node {
	var node Node
	json.NewDecoder(bytes).Decode(&node)
	return node
}

type NodeForm struct {
	Path string   `json:"path"`
	Mode string   `json:"mode"`
	Type NodeType `json:"type"`
	Sha  string   `json:"sha"`
}

func NodeFormFromMap(data interface{}) NodeForm {
	b, err := json.Marshal(data)
	if err == nil {
		return NodeFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func NodeFormFromJson(bytes io.Reader) NodeForm {
	var nodeForm NodeForm
	json.NewDecoder(bytes).Decode(&nodeForm)
	return nodeForm
}

type Person struct {
	Name  string `json:"name"`
	Email string `json:"email"`
	Date  string `json:"date"`
}

func PersonFromMap(data interface{}) Person {
	b, err := json.Marshal(data)
	if err == nil {
		return PersonFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func PersonFromJson(bytes io.Reader) Person {
	var person Person
	json.NewDecoder(bytes).Decode(&person)
	return person
}

type PullRequest struct {
	Id      int64           `json:"id"`
	Url     string          `json:"url"`
	Number  int64           `json:"number"`
	HtmlUrl string          `json:"html_url"`
	Head    PullRequestHead `json:"head"`
}

func PullRequestFromMap(data interface{}) PullRequest {
	b, err := json.Marshal(data)
	if err == nil {
		return PullRequestFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func PullRequestFromJson(bytes io.Reader) PullRequest {
	var pullRequest PullRequest
	json.NewDecoder(bytes).Decode(&pullRequest)
	return pullRequest
}

type PullRequestForm struct {
	Title string `json:"title"`
	Head  string `json:"head"`
	Base  string `json:"base"`
	Body  string `json:"body,omitempty"`
}

func PullRequestFormFromMap(data interface{}) PullRequestForm {
	b, err := json.Marshal(data)
	if err == nil {
		return PullRequestFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func PullRequestFormFromJson(bytes io.Reader) PullRequestForm {
	var pullRequestForm PullRequestForm
	json.NewDecoder(bytes).Decode(&pullRequestForm)
	return pullRequestForm
}

type PullRequestHead struct {
	Ref string `json:"ref"`
}

func PullRequestHeadFromMap(data interface{}) PullRequestHead {
	b, err := json.Marshal(data)
	if err == nil {
		return PullRequestHeadFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func PullRequestHeadFromJson(bytes io.Reader) PullRequestHead {
	var pullRequestHead PullRequestHead
	json.NewDecoder(bytes).Decode(&pullRequestHead)
	return pullRequestHead
}

type Ref struct {
	Ref    string       `json:"ref"`
	Url    string       `json:"url"`
	Object GithubObject `json:"object"`
}

func RefFromMap(data interface{}) Ref {
	b, err := json.Marshal(data)
	if err == nil {
		return RefFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func RefFromJson(bytes io.Reader) Ref {
	var ref Ref
	json.NewDecoder(bytes).Decode(&ref)
	return ref
}

type RefForm struct {
	Ref string `json:"ref"`
	Sha string `json:"sha"`
}

func RefFormFromMap(data interface{}) RefForm {
	b, err := json.Marshal(data)
	if err == nil {
		return RefFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func RefFormFromJson(bytes io.Reader) RefForm {
	var refForm RefForm
	json.NewDecoder(bytes).Decode(&refForm)
	return refForm
}

type RefUpdateForm struct {
	Sha string `json:"sha"`
}

func RefUpdateFormFromMap(data interface{}) RefUpdateForm {
	b, err := json.Marshal(data)
	if err == nil {
		return RefUpdateFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func RefUpdateFormFromJson(bytes io.Reader) RefUpdateForm {
	var refUpdateForm RefUpdateForm
	json.NewDecoder(bytes).Decode(&refUpdateForm)
	return refUpdateForm
}

type Repository struct {
	Id            int64  `json:"id"`
	Owner         User   `json:"owner"`
	Name          string `json:"name"`
	FullName      string `json:"full_name"`
	Private       string `json:"private"`
	Description   string `json:"description,omitempty"`
	Url           string `json:"url"`
	HtmlUrl       string `json:"html_url"`
	DefaultBranch string `json:"default_branch"`
}

func RepositoryFromMap(data interface{}) Repository {
	b, err := json.Marshal(data)
	if err == nil {
		return RepositoryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func RepositoryFromJson(bytes io.Reader) Repository {
	var repository Repository
	json.NewDecoder(bytes).Decode(&repository)
	return repository
}

type Tag struct {
	Tag     string       `json:"tag"`
	Sha     string       `json:"sha"`
	Url     string       `json:"url"`
	Message string       `json:"message"`
	Tagger  Tagger       `json:"tagger"`
	Object  GithubObject `json:"object"`
}

func TagFromMap(data interface{}) Tag {
	b, err := json.Marshal(data)
	if err == nil {
		return TagFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TagFromJson(bytes io.Reader) Tag {
	var tag Tag
	json.NewDecoder(bytes).Decode(&tag)
	return tag
}

type TagForm struct {
	Tag     string `json:"tag"`
	Message string `json:"message"`
	Object  string `json:"object"`
	Type    string `json:"type"`
	Tagger  Tagger `json:"tagger"`
}

func TagFormFromMap(data interface{}) TagForm {
	b, err := json.Marshal(data)
	if err == nil {
		return TagFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TagFormFromJson(bytes io.Reader) TagForm {
	var tagForm TagForm
	json.NewDecoder(bytes).Decode(&tagForm)
	return tagForm
}

type TagSummary struct {
	Name   string        `json:"name"`
	Commit CommitSummary `json:"commit"`
}

func TagSummaryFromMap(data interface{}) TagSummary {
	b, err := json.Marshal(data)
	if err == nil {
		return TagSummaryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TagSummaryFromJson(bytes io.Reader) TagSummary {
	var tagSummary TagSummary
	json.NewDecoder(bytes).Decode(&tagSummary)
	return tagSummary
}

type Tagger struct {
	Name  string `json:"name"`
	Email string `json:"email"`
	Date  string `json:"date"`
}

func TaggerFromMap(data interface{}) Tagger {
	b, err := json.Marshal(data)
	if err == nil {
		return TaggerFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TaggerFromJson(bytes io.Reader) Tagger {
	var tagger Tagger
	json.NewDecoder(bytes).Decode(&tagger)
	return tagger
}

type Tree struct {
	Sha       string `json:"sha"`
	Url       string `json:"url"`
	Truncated string `json:"truncated"`
	Tree      []Node `json:"tree"`
}

func TreeFromMap(data interface{}) Tree {
	b, err := json.Marshal(data)
	if err == nil {
		return TreeFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TreeFromJson(bytes io.Reader) Tree {
	var tree Tree
	json.NewDecoder(bytes).Decode(&tree)
	return tree
}

type TreeForm struct {
	Path    string   `json:"path"`
	Mode    string   `json:"mode"`
	Type    NodeType `json:"type"`
	Sha     string   `json:"sha,omitempty"`
	Content string   `json:"content,omitempty"`
}

func TreeFormFromMap(data interface{}) TreeForm {
	b, err := json.Marshal(data)
	if err == nil {
		return TreeFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TreeFormFromJson(bytes io.Reader) TreeForm {
	var treeForm TreeForm
	json.NewDecoder(bytes).Decode(&treeForm)
	return treeForm
}

type TreeResult struct {
	Path string   `json:"path"`
	Mode string   `json:"mode"`
	Type NodeType `json:"type"`
	Size int64    `json:"size"`
	Sha  string   `json:"sha"`
	Url  string   `json:"url"`
}

func TreeResultFromMap(data interface{}) TreeResult {
	b, err := json.Marshal(data)
	if err == nil {
		return TreeResultFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TreeResultFromJson(bytes io.Reader) TreeResult {
	var treeResult TreeResult
	json.NewDecoder(bytes).Decode(&treeResult)
	return treeResult
}

type TreeSummary struct {
	Url string `json:"url"`
	Sha string `json:"sha"`
}

func TreeSummaryFromMap(data interface{}) TreeSummary {
	b, err := json.Marshal(data)
	if err == nil {
		return TreeSummaryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TreeSummaryFromJson(bytes io.Reader) TreeSummary {
	var treeSummary TreeSummary
	json.NewDecoder(bytes).Decode(&treeSummary)
	return treeSummary
}

type UnprocessableEntity struct {
	Message string  `json:"message"`
	Errors  []Error `json:"errors,omitempty"`
}

func UnprocessableEntityFromMap(data interface{}) UnprocessableEntity {
	b, err := json.Marshal(data)
	if err == nil {
		return UnprocessableEntityFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func UnprocessableEntityFromJson(bytes io.Reader) UnprocessableEntity {
	var unprocessableEntity UnprocessableEntity
	json.NewDecoder(bytes).Decode(&unprocessableEntity)
	return unprocessableEntity
}

type User struct {
	Id         int64     `json:"id"`
	Login      string    `json:"login"`
	Name       string    `json:"name,omitempty"`
	Email      string    `json:"email,omitempty"`
	AvatarUrl  string    `json:"avatar_url,omitempty"`
	GravatarId string    `json:"gravatar_id,omitempty"`
	Url        string    `json:"url"`
	HtmlUrl    string    `json:"html_url"`
	Type       OwnerType `json:"type"`
}

func UserFromMap(data interface{}) User {
	b, err := json.Marshal(data)
	if err == nil {
		return UserFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func UserFromJson(bytes io.Reader) User {
	var user User
	json.NewDecoder(bytes).Decode(&user)
	return user
}

type UserEmail struct {
	Email    string `json:"email"`
	Verified string `json:"verified"`
	Primary  string `json:"primary"`
}

func UserEmailFromMap(data interface{}) UserEmail {
	b, err := json.Marshal(data)
	if err == nil {
		return UserEmailFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func UserEmailFromJson(bytes io.Reader) UserEmail {
	var userEmail UserEmail
	json.NewDecoder(bytes).Decode(&userEmail)
	return userEmail
}

type UserOrg struct {
	Login string `json:"login"`
}

func UserOrgFromMap(data interface{}) UserOrg {
	b, err := json.Marshal(data)
	if err == nil {
		return UserOrgFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func UserOrgFromJson(bytes io.Reader) UserOrg {
	var userOrg UserOrg
	json.NewDecoder(bytes).Decode(&userOrg)
	return userOrg
}

type BlobsGetByShaResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Blob       Blob
}

func BlobsGetBySha(client Client, owner string, repo string, sha string) BlobsGetByShaResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/git/blobs/%s", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo), html.EscapeString(sha))

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return BlobsGetByShaResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return BlobsGetByShaResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return BlobsGetByShaResponse{StatusCode: resp.StatusCode, Response: resp, Blob: BlobFromJson(resp.Body)}

	case 404:
		return BlobsGetByShaResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return BlobsGetByShaResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type BlobsPostResponse struct {
	StatusCode          int
	Response            *http.Response
	Error               error
	BlobCreated         BlobCreated
	UnprocessableEntity UnprocessableEntity
}

func BlobsPost(client Client, owner string, repo string, blobForm BlobForm) BlobsPostResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/git/blobs", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo))


	if "" == blobForm.Encoding {
		blobForm.Encoding = EncodingFromString("utf-8")
	}

	bodyDocument, err := json.Marshal(blobForm)
	if err != nil {
		return BlobsPostResponse{Error: err}
	}
	body := ClientRequestBody{contentType: "application/json", bytes: bytes.NewReader(bodyDocument)}

	request, err := buildRequest(client, "POST", requestUrl, body)
	if err != nil {
		return BlobsPostResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return BlobsPostResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 201:
		return BlobsPostResponse{StatusCode: resp.StatusCode, Response: resp, BlobCreated: BlobCreatedFromJson(resp.Body)}

	case 404:
		return BlobsPostResponse{StatusCode: resp.StatusCode, Response: resp}

	case 422:
		return BlobsPostResponse{StatusCode: resp.StatusCode, Response: resp, UnprocessableEntity: UnprocessableEntityFromJson(resp.Body)}

	default:
		return BlobsPostResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type CommitsGetByShaResponse struct {
	StatusCode          int
	Response            *http.Response
	Error               error
	Commit              Commit
	UnprocessableEntity UnprocessableEntity
}

func CommitsGetBySha(client Client, owner string, repo string, sha string) CommitsGetByShaResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/git/commits/%s", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo), html.EscapeString(sha))

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return CommitsGetByShaResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return CommitsGetByShaResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return CommitsGetByShaResponse{StatusCode: resp.StatusCode, Response: resp, Commit: CommitFromJson(resp.Body)}

	case 404:
		return CommitsGetByShaResponse{StatusCode: resp.StatusCode, Response: resp}

	case 422:
		return CommitsGetByShaResponse{StatusCode: resp.StatusCode, Response: resp, UnprocessableEntity: UnprocessableEntityFromJson(resp.Body)}

	default:
		return CommitsGetByShaResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type CommitsPostResponse struct {
	StatusCode          int
	Response            *http.Response
	Error               error
	CommitResponse      CommitResponse
	UnprocessableEntity UnprocessableEntity
}

func CommitsPost(client Client, owner string, repo string, commitForm CommitForm) CommitsPostResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/git/commits", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo))

	bodyDocument, err := json.Marshal(commitForm)
	if err != nil {
		return CommitsPostResponse{Error: err}
	}
	body := ClientRequestBody{contentType: "application/json", bytes: bytes.NewReader(bodyDocument)}

	request, err := buildRequest(client, "POST", requestUrl, body)
	if err != nil {
		return CommitsPostResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return CommitsPostResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 201:
		return CommitsPostResponse{StatusCode: resp.StatusCode, Response: resp, CommitResponse: CommitResponseFromJson(resp.Body)}

	case 404:
		return CommitsPostResponse{StatusCode: resp.StatusCode, Response: resp}

	case 422:
		return CommitsPostResponse{StatusCode: resp.StatusCode, Response: resp, UnprocessableEntity: UnprocessableEntityFromJson(resp.Body)}

	default:
		return CommitsPostResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type ContentsGetReadmeParams struct {
	Ref string
}

type ContentsGetReadmeResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Contents   Contents
}

func ContentsGetReadme(client Client, owner string, repo string, params ContentsGetReadmeParams) ContentsGetReadmeResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/readme", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo))
	urlValues := url.Values{}
	if "" == params.Ref {
		urlValues.Add("ref", "master")
	} else {
		urlValues.Add("ref", params.Ref)
	}

	encodedValues := urlValues.Encode()
	if encodedValues != "" {
		requestUrl += "?" + encodedValues
	}

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return ContentsGetReadmeResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return ContentsGetReadmeResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return ContentsGetReadmeResponse{StatusCode: resp.StatusCode, Response: resp, Contents: ContentsFromJson(resp.Body)}

	case 401:
		return ContentsGetReadmeResponse{StatusCode: resp.StatusCode, Response: resp}

	case 404:
		return ContentsGetReadmeResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return ContentsGetReadmeResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type ContentsGetContentsByPathParams struct {
	Ref string
}

type ContentsGetContentsByPathResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Contents   Contents
}

func ContentsGetContentsByPath(client Client, owner string, repo string, path string, params ContentsGetContentsByPathParams) ContentsGetContentsByPathResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/contents/%s", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo), html.EscapeString(path))
	urlValues := url.Values{}
	if "" == params.Ref {
		urlValues.Add("ref", "master")
	} else {
		urlValues.Add("ref", params.Ref)
	}

	encodedValues := urlValues.Encode()
	if encodedValues != "" {
		requestUrl += "?" + encodedValues
	}

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return ContentsGetContentsByPathResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return ContentsGetContentsByPathResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return ContentsGetContentsByPathResponse{StatusCode: resp.StatusCode, Response: resp, Contents: ContentsFromJson(resp.Body)}

	case 401:
		return ContentsGetContentsByPathResponse{StatusCode: resp.StatusCode, Response: resp}

	case 404:
		return ContentsGetContentsByPathResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return ContentsGetContentsByPathResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type HooksGetResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Hooks      []Hook
}

func HooksGet(client Client, owner string, repo string) HooksGetResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/hooks", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo))

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return HooksGetResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return HooksGetResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return HooksGetResponse{StatusCode: resp.StatusCode, Response: resp, Hooks: func() []Hook {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []Hook
			for _, el := range tmp {
				all = append(all, HookFromMap(el))
			}
			return all
		}()}

	case 404:
		return HooksGetResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return HooksGetResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type HooksGetByIdResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Hook       Hook
}

func HooksGetById(client Client, owner string, repo string, id int64) HooksGetByIdResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/hooks/%s", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo), strconv.FormatInt(id, 10))

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return HooksGetByIdResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return HooksGetByIdResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return HooksGetByIdResponse{StatusCode: resp.StatusCode, Response: resp, Hook: HookFromJson(resp.Body)}

	case 404:
		return HooksGetByIdResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return HooksGetByIdResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type HooksPostResponse struct {
	StatusCode          int
	Response            *http.Response
	Error               error
	Hook                Hook
	UnprocessableEntity UnprocessableEntity
}

func HooksPost(client Client, owner string, repo string, hookForm HookForm) HooksPostResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/hooks", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo))

	bodyDocument, err := json.Marshal(hookForm)
	if err != nil {
		return HooksPostResponse{Error: err}
	}
	body := ClientRequestBody{contentType: "application/json", bytes: bytes.NewReader(bodyDocument)}

	request, err := buildRequest(client, "POST", requestUrl, body)
	if err != nil {
		return HooksPostResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return HooksPostResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 201:
		return HooksPostResponse{StatusCode: resp.StatusCode, Response: resp, Hook: HookFromJson(resp.Body)}

	case 404:
		return HooksPostResponse{StatusCode: resp.StatusCode, Response: resp}

	case 422:
		return HooksPostResponse{StatusCode: resp.StatusCode, Response: resp, UnprocessableEntity: UnprocessableEntityFromJson(resp.Body)}

	default:
		return HooksPostResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type HooksDeleteByIdResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
}

func HooksDeleteById(client Client, owner string, repo string, id int64) HooksDeleteByIdResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/hooks/%s", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo), strconv.FormatInt(id, 10))

	request, err := buildRequest(client, "DELETE", requestUrl, ClientRequestBody{})
	if err != nil {
		return HooksDeleteByIdResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return HooksDeleteByIdResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 204:
		return HooksDeleteByIdResponse{StatusCode: resp.StatusCode, Response: resp}

	case 404:
		return HooksDeleteByIdResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return HooksDeleteByIdResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type PullRequestsPostResponse struct {
	StatusCode          int
	Response            *http.Response
	Error               error
	PullRequest         PullRequest
	UnprocessableEntity UnprocessableEntity
}

func PullRequestsPost(client Client, owner string, repo string, pullRequestForm PullRequestForm) PullRequestsPostResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/pulls", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo))

	bodyDocument, err := json.Marshal(pullRequestForm)
	if err != nil {
		return PullRequestsPostResponse{Error: err}
	}
	body := ClientRequestBody{contentType: "application/json", bytes: bytes.NewReader(bodyDocument)}

	request, err := buildRequest(client, "POST", requestUrl, body)
	if err != nil {
		return PullRequestsPostResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return PullRequestsPostResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 201:
		return PullRequestsPostResponse{StatusCode: resp.StatusCode, Response: resp, PullRequest: PullRequestFromJson(resp.Body)}

	case 404:
		return PullRequestsPostResponse{StatusCode: resp.StatusCode, Response: resp}

	case 422:
		return PullRequestsPostResponse{StatusCode: resp.StatusCode, Response: resp, UnprocessableEntity: UnprocessableEntityFromJson(resp.Body)}

	default:
		return PullRequestsPostResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type PullRequestsGetParams struct {
	Page int64
}

type PullRequestsGetResponse struct {
	StatusCode   int
	Response     *http.Response
	Error        error
	PullRequests []PullRequest
}

func PullRequestsGet(client Client, owner string, repo string, params PullRequestsGetParams) PullRequestsGetResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/pulls", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo))
	urlValues := url.Values{}
	if 0 == params.Page {
		urlValues.Add("page", strconv.FormatInt(1, 10))
	} else {
		urlValues.Add("page", strconv.FormatInt(params.Page, 10))
	}

	encodedValues := urlValues.Encode()
	if encodedValues != "" {
		requestUrl += "?" + encodedValues
	}

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return PullRequestsGetResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return PullRequestsGetResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return PullRequestsGetResponse{StatusCode: resp.StatusCode, Response: resp, PullRequests: func() []PullRequest {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []PullRequest
			for _, el := range tmp {
				all = append(all, PullRequestFromMap(el))
			}
			return all
		}()}

	case 404:
		return PullRequestsGetResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return PullRequestsGetResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type RefsGetResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Refs       []Ref
}

func RefsGet(client Client, owner string, repo string) RefsGetResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/git/refs", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo))

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return RefsGetResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return RefsGetResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return RefsGetResponse{StatusCode: resp.StatusCode, Response: resp, Refs: func() []Ref {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []Ref
			for _, el := range tmp {
				all = append(all, RefFromMap(el))
			}
			return all
		}()}

	case 404:
		return RefsGetResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return RefsGetResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type RefsGetByRefResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Ref        Ref
}

func RefsGetByRef(client Client, owner string, repo string, ref string) RefsGetByRefResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/git/refs/%s", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo), html.EscapeString(ref))

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return RefsGetByRefResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return RefsGetByRefResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return RefsGetByRefResponse{StatusCode: resp.StatusCode, Response: resp, Ref: RefFromJson(resp.Body)}

	case 404:
		return RefsGetByRefResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return RefsGetByRefResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type RefsPostResponse struct {
	StatusCode          int
	Response            *http.Response
	Error               error
	Ref                 Ref
	UnprocessableEntity UnprocessableEntity
}

func RefsPost(client Client, owner string, repo string, refForm RefForm) RefsPostResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/git/refs", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo))

	bodyDocument, err := json.Marshal(refForm)
	if err != nil {
		return RefsPostResponse{Error: err}
	}
	body := ClientRequestBody{contentType: "application/json", bytes: bytes.NewReader(bodyDocument)}

	request, err := buildRequest(client, "POST", requestUrl, body)
	if err != nil {
		return RefsPostResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return RefsPostResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 201:
		return RefsPostResponse{StatusCode: resp.StatusCode, Response: resp, Ref: RefFromJson(resp.Body)}

	case 404:
		return RefsPostResponse{StatusCode: resp.StatusCode, Response: resp}

	case 422:
		return RefsPostResponse{StatusCode: resp.StatusCode, Response: resp, UnprocessableEntity: UnprocessableEntityFromJson(resp.Body)}

	default:
		return RefsPostResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type RefsPutByRefResponse struct {
	StatusCode          int
	Response            *http.Response
	Error               error
	Ref                 Ref
	UnprocessableEntity UnprocessableEntity
}

func RefsPutByRef(client Client, owner string, repo string, ref string, refUpdateForm RefUpdateForm) RefsPutByRefResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/git/refs/%s", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo), html.EscapeString(ref))

	bodyDocument, err := json.Marshal(refUpdateForm)
	if err != nil {
		return RefsPutByRefResponse{Error: err}
	}
	body := ClientRequestBody{contentType: "application/json", bytes: bytes.NewReader(bodyDocument)}

	request, err := buildRequest(client, "PUT", requestUrl, body)
	if err != nil {
		return RefsPutByRefResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return RefsPutByRefResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 201:
		return RefsPutByRefResponse{StatusCode: resp.StatusCode, Response: resp, Ref: RefFromJson(resp.Body)}

	case 404:
		return RefsPutByRefResponse{StatusCode: resp.StatusCode, Response: resp}

	case 422:
		return RefsPutByRefResponse{StatusCode: resp.StatusCode, Response: resp, UnprocessableEntity: UnprocessableEntityFromJson(resp.Body)}

	default:
		return RefsPutByRefResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type RepositoriesGetUserAndReposParams struct {
	Page        int64
	Visibility  Visibility
	Affiliation string
	Type        string
	Sort        string
	Direction   string
}

type RepositoriesGetUserAndReposResponse struct {
	StatusCode   int
	Response     *http.Response
	Error        error
	Repositories []Repository
}

func RepositoriesGetUserAndRepos(client Client, params RepositoriesGetUserAndReposParams) RepositoriesGetUserAndReposResponse {

	requestUrl := fmt.Sprintf("%s/user/repos", client.BaseUrl)
	urlValues := url.Values{}
	if 0 == params.Page {
		urlValues.Add("page", strconv.FormatInt(1, 10))
	} else {
		urlValues.Add("page", strconv.FormatInt(params.Page, 10))
	}
	if "" == params.Visibility {
		urlValues.Add("visibility", string("all"))
	} else {
		urlValues.Add("visibility", string(params.Visibility))
	}
	if "" != params.Affiliation {
		urlValues.Add("affiliation", params.Affiliation)
	}
	if "" != params.Type {
		urlValues.Add("type", params.Type)
	}
	if "" == params.Sort {
		urlValues.Add("sort", "full_name")
	} else {
		urlValues.Add("sort", params.Sort)
	}
	if "" == params.Direction {
		urlValues.Add("direction", "asc")
	} else {
		urlValues.Add("direction", params.Direction)
	}

	encodedValues := urlValues.Encode()
	if encodedValues != "" {
		requestUrl += "?" + encodedValues
	}

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return RepositoriesGetUserAndReposResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return RepositoriesGetUserAndReposResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return RepositoriesGetUserAndReposResponse{StatusCode: resp.StatusCode, Response: resp, Repositories: func() []Repository {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []Repository
			for _, el := range tmp {
				all = append(all, RepositoryFromMap(el))
			}
			return all
		}()}

	case 401:
		return RepositoriesGetUserAndReposResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return RepositoriesGetUserAndReposResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type RepositoriesGetUsersAndReposByUsernameParams struct {
	Page      int64
	Type      string
	Sort      string
	Direction string
}

type RepositoriesGetUsersAndReposByUsernameResponse struct {
	StatusCode   int
	Response     *http.Response
	Error        error
	Repositories []Repository
}

func RepositoriesGetUsersAndReposByUsername(client Client, username string, params RepositoriesGetUsersAndReposByUsernameParams) RepositoriesGetUsersAndReposByUsernameResponse {

	requestUrl := fmt.Sprintf("%s/users/%s/repos", client.BaseUrl, html.EscapeString(username))
	urlValues := url.Values{}
	if 0 == params.Page {
		urlValues.Add("page", strconv.FormatInt(1, 10))
	} else {
		urlValues.Add("page", strconv.FormatInt(params.Page, 10))
	}
	if "" == params.Type {
		urlValues.Add("type", "owner")
	} else {
		urlValues.Add("type", params.Type)
	}
	if "" == params.Sort {
		urlValues.Add("sort", "full_name")
	} else {
		urlValues.Add("sort", params.Sort)
	}
	if "" == params.Direction {
		urlValues.Add("direction", "asc")
	} else {
		urlValues.Add("direction", params.Direction)
	}

	encodedValues := urlValues.Encode()
	if encodedValues != "" {
		requestUrl += "?" + encodedValues
	}

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return RepositoriesGetUsersAndReposByUsernameResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return RepositoriesGetUsersAndReposByUsernameResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return RepositoriesGetUsersAndReposByUsernameResponse{StatusCode: resp.StatusCode, Response: resp, Repositories: func() []Repository {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []Repository
			for _, el := range tmp {
				all = append(all, RepositoryFromMap(el))
			}
			return all
		}()}

	case 401:
		return RepositoriesGetUsersAndReposByUsernameResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return RepositoriesGetUsersAndReposByUsernameResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type RepositoriesGetOrgsAndReposByOrgParams struct {
	Page      int64
	Type      string
	Sort      string
	Direction string
}

type RepositoriesGetOrgsAndReposByOrgResponse struct {
	StatusCode   int
	Response     *http.Response
	Error        error
	Repositories []Repository
}

func RepositoriesGetOrgsAndReposByOrg(client Client, org string, params RepositoriesGetOrgsAndReposByOrgParams) RepositoriesGetOrgsAndReposByOrgResponse {

	requestUrl := fmt.Sprintf("%s/orgs/%s/repos", client.BaseUrl, html.EscapeString(org))
	urlValues := url.Values{}
	if 0 == params.Page {
		urlValues.Add("page", strconv.FormatInt(1, 10))
	} else {
		urlValues.Add("page", strconv.FormatInt(params.Page, 10))
	}
	if "" == params.Type {
		urlValues.Add("type", "all")
	} else {
		urlValues.Add("type", params.Type)
	}
	if "" == params.Sort {
		urlValues.Add("sort", "full_name")
	} else {
		urlValues.Add("sort", params.Sort)
	}
	if "" == params.Direction {
		urlValues.Add("direction", "asc")
	} else {
		urlValues.Add("direction", params.Direction)
	}

	encodedValues := urlValues.Encode()
	if encodedValues != "" {
		requestUrl += "?" + encodedValues
	}

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return RepositoriesGetOrgsAndReposByOrgResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return RepositoriesGetOrgsAndReposByOrgResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return RepositoriesGetOrgsAndReposByOrgResponse{StatusCode: resp.StatusCode, Response: resp, Repositories: func() []Repository {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []Repository
			for _, el := range tmp {
				all = append(all, RepositoryFromMap(el))
			}
			return all
		}()}

	case 401:
		return RepositoriesGetOrgsAndReposByOrgResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return RepositoriesGetOrgsAndReposByOrgResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type TagsGetTagsParams struct {
	Page    int64
	PerPage int64
}

type TagsGetTagsResponse struct {
	StatusCode   int
	Response     *http.Response
	Error        error
	TagSummaries []TagSummary
}

func TagsGetTags(client Client, owner string, repo string, params TagsGetTagsParams) TagsGetTagsResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/tags", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo))
	urlValues := url.Values{}
	if 0 == params.Page {
		urlValues.Add("page", strconv.FormatInt(1, 10))
	} else {
		urlValues.Add("page", strconv.FormatInt(params.Page, 10))
	}
	if 0 == params.PerPage {
		urlValues.Add("per_page", strconv.FormatInt(30, 10))
	} else {
		urlValues.Add("per_page", strconv.FormatInt(params.PerPage, 10))
	}

	encodedValues := urlValues.Encode()
	if encodedValues != "" {
		requestUrl += "?" + encodedValues
	}

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return TagsGetTagsResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return TagsGetTagsResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return TagsGetTagsResponse{StatusCode: resp.StatusCode, Response: resp, TagSummaries: func() []TagSummary {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []TagSummary
			for _, el := range tmp {
				all = append(all, TagSummaryFromMap(el))
			}
			return all
		}()}

	case 404:
		return TagsGetTagsResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return TagsGetTagsResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type TagsGetTagsByShaResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Tag        Tag
}

func TagsGetTagsBySha(client Client, owner string, repo string, sha string) TagsGetTagsByShaResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/tags/%s", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo), html.EscapeString(sha))

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return TagsGetTagsByShaResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return TagsGetTagsByShaResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return TagsGetTagsByShaResponse{StatusCode: resp.StatusCode, Response: resp, Tag: TagFromJson(resp.Body)}

	case 404:
		return TagsGetTagsByShaResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return TagsGetTagsByShaResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type TagsPostGitAndTagsResponse struct {
	StatusCode          int
	Response            *http.Response
	Error               error
	Tag                 Tag
	UnprocessableEntity UnprocessableEntity
}

func TagsPostGitAndTags(client Client, owner string, repo string, tagForm TagForm) TagsPostGitAndTagsResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/git/tags", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo))


	if "" == tagForm.Type {
		tagForm.Type = "commit"
	}

	bodyDocument, err := json.Marshal(tagForm)
	if err != nil {
		return TagsPostGitAndTagsResponse{Error: err}
	}
	body := ClientRequestBody{contentType: "application/json", bytes: bytes.NewReader(bodyDocument)}

	request, err := buildRequest(client, "POST", requestUrl, body)
	if err != nil {
		return TagsPostGitAndTagsResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return TagsPostGitAndTagsResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 201:
		return TagsPostGitAndTagsResponse{StatusCode: resp.StatusCode, Response: resp, Tag: TagFromJson(resp.Body)}

	case 404:
		return TagsPostGitAndTagsResponse{StatusCode: resp.StatusCode, Response: resp}

	case 422:
		return TagsPostGitAndTagsResponse{StatusCode: resp.StatusCode, Response: resp, UnprocessableEntity: UnprocessableEntityFromJson(resp.Body)}

	default:
		return TagsPostGitAndTagsResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type TreesPostResponse struct {
	StatusCode          int
	Response            *http.Response
	Error               error
	CreateTreeResponse  CreateTreeResponse
	UnprocessableEntity UnprocessableEntity
}

func TreesPost(client Client, owner string, repo string, createTreeForm CreateTreeForm) TreesPostResponse {

	requestUrl := fmt.Sprintf("%s/repos/%s/%s/git/trees", client.BaseUrl, html.EscapeString(owner), html.EscapeString(repo))

	bodyDocument, err := json.Marshal(createTreeForm)
	if err != nil {
		return TreesPostResponse{Error: err}
	}
	body := ClientRequestBody{contentType: "application/json", bytes: bytes.NewReader(bodyDocument)}

	request, err := buildRequest(client, "POST", requestUrl, body)
	if err != nil {
		return TreesPostResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return TreesPostResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 201:
		return TreesPostResponse{StatusCode: resp.StatusCode, Response: resp, CreateTreeResponse: CreateTreeResponseFromJson(resp.Body)}

	case 404:
		return TreesPostResponse{StatusCode: resp.StatusCode, Response: resp}

	case 422:
		return TreesPostResponse{StatusCode: resp.StatusCode, Response: resp, UnprocessableEntity: UnprocessableEntityFromJson(resp.Body)}

	default:
		return TreesPostResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type UsersGetUserResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	User       User
}

func UsersGetUser(client Client) UsersGetUserResponse {

	requestUrl := fmt.Sprintf("%s/user", client.BaseUrl)

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return UsersGetUserResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return UsersGetUserResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return UsersGetUserResponse{StatusCode: resp.StatusCode, Response: resp, User: UserFromJson(resp.Body)}

	case 401:
		return UsersGetUserResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return UsersGetUserResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type UsersGetUserAndOrgsParams struct {
	Page    int64
	PerPage int64
}

type UsersGetUserAndOrgsResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	UserOrgs   []UserOrg
}

func UsersGetUserAndOrgs(client Client, params UsersGetUserAndOrgsParams) UsersGetUserAndOrgsResponse {

	requestUrl := fmt.Sprintf("%s/user/orgs", client.BaseUrl)
	urlValues := url.Values{}
	if 0 == params.Page {
		urlValues.Add("page", strconv.FormatInt(1, 10))
	} else {
		urlValues.Add("page", strconv.FormatInt(params.Page, 10))
	}
	if 0 != params.PerPage {
		urlValues.Add("per_page", strconv.FormatInt(params.PerPage, 10))
	}

	encodedValues := urlValues.Encode()
	if encodedValues != "" {
		requestUrl += "?" + encodedValues
	}

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return UsersGetUserAndOrgsResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return UsersGetUserAndOrgsResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return UsersGetUserAndOrgsResponse{StatusCode: resp.StatusCode, Response: resp, UserOrgs: func() []UserOrg {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []UserOrg
			for _, el := range tmp {
				all = append(all, UserOrgFromMap(el))
			}
			return all
		}()}

	case 401:
		return UsersGetUserAndOrgsResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return UsersGetUserAndOrgsResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type UserEmailsGetResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	UserEmails []UserEmail
}

func UserEmailsGet(client Client) UserEmailsGetResponse {

	requestUrl := fmt.Sprintf("%s/user/emails", client.BaseUrl)

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return UserEmailsGetResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return UserEmailsGetResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return UserEmailsGetResponse{StatusCode: resp.StatusCode, Response: resp, UserEmails: func() []UserEmail {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []UserEmail
			for _, el := range tmp {
				all = append(all, UserEmailFromMap(el))
			}
			return all
		}()}

	case 401:
		return UserEmailsGetResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return UserEmailsGetResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

func buildRequest(client Client, method, urlStr string, body ClientRequestBody) (*http.Request, error) {

	request, err := http.NewRequest(method, urlStr, body.bytes)
	if err != nil {
		return nil, err
	}

	request.Header = map[string][]string{
		"User-Agent":             {UserAgent},
		"X-Apidoc-Version":       {Version},
		"X-Apidoc-Version-Major": {strconv.Itoa(VersionMajor)},
	}

	if body.contentType != "" {
		request.Header["Content-type"] = []string{body.contentType}
	}

	if client.Username != "" {
		request.SetBasicAuth(client.Username, client.Password)
	}

	return request, nil

}