package dependency

/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.8.18
 * User agent: apibuilder app.apibuilder.io/flow/dependency/0.8.18/go_1_5_client
 */

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"html"
	"io"
	"io/flow/common"
	"io/flow/error"
	"io/flow/github"
	"io/flow/healthcheck"
	"net/http"
	"net/url"
	"strconv"
	"strings"
)

const UserAgent = "apibuilder app.apibuilder.io/flow/dependency/0.8.18/go_1_5_client"
const Version = "0.8.18"
const VersionMajor = 0

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

type ClientRequestBody struct {
	contentType string
	bytes       io.Reader
}

type BinaryType string

const (
	BinaryTypeScala BinaryType  = "scala"     // See http://www.scala-lang.org/
	BinaryTypeSbt               = "sbt"       // See http://www.scala-sbt.org/
	BinaryTypeUNDEFINED         = "UNDEFINED"
)

func BinaryTypeFromString(value string) BinaryType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "scala":
		return BinaryTypeScala
	case "sbt":
		return BinaryTypeSbt
	default:
		return BinaryTypeUNDEFINED
	}
}

/**
 * A publication represents something that a user can subscribe to.
 */
type Publication string

const (
	PublicationDailySummary Publication  = "daily_summary" // A daily summary of dependencies that can be upgraded
	PublicationUNDEFINED                 = "UNDEFINED"
)

func PublicationFromString(value string) Publication {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "daily_summary":
		return PublicationDailySummary
	default:
		return PublicationUNDEFINED
	}
}

type RecommendationType string

const (
	RecommendationTypeLibrary RecommendationType  = "library"
	RecommendationTypeBinary                      = "binary"
	RecommendationTypeUNDEFINED                   = "UNDEFINED"
)

func RecommendationTypeFromString(value string) RecommendationType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "library":
		return RecommendationTypeLibrary
	case "binary":
		return RecommendationTypeBinary
	default:
		return RecommendationTypeUNDEFINED
	}
}

type Role string

const (
	RoleMember Role  = "member"
	RoleAdmin        = "admin"
	RoleUNDEFINED    = "UNDEFINED"
)

func RoleFromString(value string) Role {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "member":
		return RoleMember
	case "admin":
		return RoleAdmin
	default:
		return RoleUNDEFINED
	}
}

type Scms string

const (
	ScmsGithub Scms  = "github"
	ScmsUNDEFINED    = "UNDEFINED"
)

func ScmsFromString(value string) Scms {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "github":
		return ScmsGithub
	default:
		return ScmsUNDEFINED
	}
}

type SyncEvent string

const (
	SyncEventStarted SyncEvent  = "started"
	SyncEventCompleted          = "completed"
	SyncEventUNDEFINED          = "UNDEFINED"
)

func SyncEventFromString(value string) SyncEvent {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "started":
		return SyncEventStarted
	case "completed":
		return SyncEventCompleted
	default:
		return SyncEventUNDEFINED
	}
}

type SyncType string

const (
	SyncTypeProject SyncType  = "project"
	SyncTypeLibrary           = "library"
	SyncTypeBinary            = "binary"
	SyncTypeUNDEFINED         = "UNDEFINED"
)

func SyncTypeFromString(value string) SyncType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "project":
		return SyncTypeProject
	case "library":
		return SyncTypeLibrary
	case "binary":
		return SyncTypeBinary
	default:
		return SyncTypeUNDEFINED
	}
}

type Visibility string

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

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

type Binary struct {
	Id           string              `json:"id"`
	Organization OrganizationSummary `json:"organization"`
	Name         BinaryType          `json:"name"`
}

func BinaryFromMap(data interface{}) Binary {
	b, err := json.Marshal(data)
	if err == nil {
		return BinaryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func BinaryFromJson(bytes io.Reader) Binary {
	var binary Binary
	json.NewDecoder(bytes).Decode(&binary)
	return binary
}

type BinaryForm struct {
	OrganizationId string     `json:"organization_id"`
	Name           BinaryType `json:"name"`
}

func BinaryFormFromMap(data interface{}) BinaryForm {
	b, err := json.Marshal(data)
	if err == nil {
		return BinaryFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func BinaryFormFromJson(bytes io.Reader) BinaryForm {
	var binaryForm BinaryForm
	json.NewDecoder(bytes).Decode(&binaryForm)
	return binaryForm
}

type BinarySummary struct {
	Id           string              `json:"id"`
	Organization OrganizationSummary `json:"organization"`
	Name         BinaryType          `json:"name"`
}

func BinarySummaryFromMap(data interface{}) BinarySummary {
	b, err := json.Marshal(data)
	if err == nil {
		return BinarySummaryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func BinarySummaryFromJson(bytes io.Reader) BinarySummary {
	var binarySummary BinarySummary
	json.NewDecoder(bytes).Decode(&binarySummary)
	return binarySummary
}

type BinaryVersion struct {
	Id      string `json:"id"`
	Binary  Binary `json:"binary"`
	Version string `json:"version"`
}

func BinaryVersionFromMap(data interface{}) BinaryVersion {
	b, err := json.Marshal(data)
	if err == nil {
		return BinaryVersionFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func BinaryVersionFromJson(bytes io.Reader) BinaryVersion {
	var binaryVersion BinaryVersion
	json.NewDecoder(bytes).Decode(&binaryVersion)
	return binaryVersion
}

/**
 * Used to authenticate user based on the oauth code we receive from github
 */
type GithubAuthenticationForm struct {
	Code string `json:"code"`
}

func GithubAuthenticationFormFromMap(data interface{}) GithubAuthenticationForm {
	b, err := json.Marshal(data)
	if err == nil {
		return GithubAuthenticationFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func GithubAuthenticationFormFromJson(bytes io.Reader) GithubAuthenticationForm {
	var githubAuthenticationForm GithubAuthenticationForm
	json.NewDecoder(bytes).Decode(&githubAuthenticationForm)
	return githubAuthenticationForm
}

type GithubUser struct {
	Id           string               `json:"id"`
	User         common.UserReference `json:"user"`
	GithubUserId int64                `json:"github_user_id"`
	Login        string               `json:"login"`
}

func GithubUserFromMap(data interface{}) GithubUser {
	b, err := json.Marshal(data)
	if err == nil {
		return GithubUserFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func GithubUserFromJson(bytes io.Reader) GithubUser {
	var githubUser GithubUser
	json.NewDecoder(bytes).Decode(&githubUser)
	return githubUser
}

type GithubUserForm struct {
	UserId       string `json:"user_id"`
	GithubUserId int64  `json:"github_user_id"`
	Login        string `json:"login"`
}

func GithubUserFormFromMap(data interface{}) GithubUserForm {
	b, err := json.Marshal(data)
	if err == nil {
		return GithubUserFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func GithubUserFormFromJson(bytes io.Reader) GithubUserForm {
	var githubUserForm GithubUserForm
	json.NewDecoder(bytes).Decode(&githubUserForm)
	return githubUserForm
}

/**
 * Defines a github hook
 */
type GithubWebhook struct {
	Id int64 `json:"id"`
}

func GithubWebhookFromMap(data interface{}) GithubWebhook {
	b, err := json.Marshal(data)
	if err == nil {
		return GithubWebhookFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func GithubWebhookFromJson(bytes io.Reader) GithubWebhook {
	var githubWebhook GithubWebhook
	json.NewDecoder(bytes).Decode(&githubWebhook)
	return githubWebhook
}

/**
 * A denormalization of item content for search
 */
type Item struct {
	Id           string              `json:"id"`
	Organization OrganizationSummary `json:"organization"`
	Visibility   Visibility          `json:"visibility"`
	Summary      ItemSummary         `json:"summary"`
	Label        string              `json:"label"`
	Description  string              `json:"description,omitempty"`
}

func ItemFromMap(data interface{}) Item {
	b, err := json.Marshal(data)
	if err == nil {
		return ItemFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ItemFromJson(bytes io.Reader) Item {
	var item Item
	json.NewDecoder(bytes).Decode(&item)
	return item
}

type Library struct {
	Id           string              `json:"id"`
	Organization OrganizationSummary `json:"organization"`
	GroupId      string              `json:"group_id"`
	ArtifactId   string              `json:"artifact_id"`
	Resolver     ResolverSummary     `json:"resolver"`
}

func LibraryFromMap(data interface{}) Library {
	b, err := json.Marshal(data)
	if err == nil {
		return LibraryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func LibraryFromJson(bytes io.Reader) Library {
	var library Library
	json.NewDecoder(bytes).Decode(&library)
	return library
}

type LibraryForm struct {
	OrganizationId string      `json:"organization_id"`
	GroupId        string      `json:"group_id"`
	ArtifactId     string      `json:"artifact_id"`
	ResolverId     string      `json:"resolver_id"`
	Version        VersionForm `json:"version,omitempty"`
}

func LibraryFormFromMap(data interface{}) LibraryForm {
	b, err := json.Marshal(data)
	if err == nil {
		return LibraryFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func LibraryFormFromJson(bytes io.Reader) LibraryForm {
	var libraryForm LibraryForm
	json.NewDecoder(bytes).Decode(&libraryForm)
	return libraryForm
}

type LibrarySummary struct {
	Id           string              `json:"id"`
	Organization OrganizationSummary `json:"organization"`
	GroupId      string              `json:"group_id"`
	ArtifactId   string              `json:"artifact_id"`
}

func LibrarySummaryFromMap(data interface{}) LibrarySummary {
	b, err := json.Marshal(data)
	if err == nil {
		return LibrarySummaryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func LibrarySummaryFromJson(bytes io.Reader) LibrarySummary {
	var librarySummary LibrarySummary
	json.NewDecoder(bytes).Decode(&librarySummary)
	return librarySummary
}

type LibraryVersion struct {
	Id                string  `json:"id"`
	Library           Library `json:"library"`
	Version           string  `json:"version"`
	CrossBuildVersion string  `json:"cross_build_version,omitempty"`
}

func LibraryVersionFromMap(data interface{}) LibraryVersion {
	b, err := json.Marshal(data)
	if err == nil {
		return LibraryVersionFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func LibraryVersionFromJson(bytes io.Reader) LibraryVersion {
	var libraryVersion LibraryVersion
	json.NewDecoder(bytes).Decode(&libraryVersion)
	return libraryVersion
}

/**
 * A user can belong to one or more organizations via memberships.
 */
type Membership struct {
	Id           string              `json:"id"`
	User         UserSummary         `json:"user"`
	Organization OrganizationSummary `json:"organization"`
	Role         Role                `json:"role"`
}

func MembershipFromMap(data interface{}) Membership {
	b, err := json.Marshal(data)
	if err == nil {
		return MembershipFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func MembershipFromJson(bytes io.Reader) Membership {
	var membership Membership
	json.NewDecoder(bytes).Decode(&membership)
	return membership
}

type MembershipForm struct {
	UserId       string `json:"user_id"`
	Organization string `json:"organization"`
	Role         Role   `json:"role"`
}

func MembershipFormFromMap(data interface{}) MembershipForm {
	b, err := json.Marshal(data)
	if err == nil {
		return MembershipFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func MembershipFormFromJson(bytes io.Reader) MembershipForm {
	var membershipForm MembershipForm
	json.NewDecoder(bytes).Decode(&membershipForm)
	return membershipForm
}

type Organization struct {
	Id   string               `json:"id"`
	User common.UserReference `json:"user"`
	Key  string               `json:"key"`
}

func OrganizationFromMap(data interface{}) Organization {
	b, err := json.Marshal(data)
	if err == nil {
		return OrganizationFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func OrganizationFromJson(bytes io.Reader) Organization {
	var organization Organization
	json.NewDecoder(bytes).Decode(&organization)
	return organization
}

type OrganizationForm struct {
	Key string `json:"key"`
}

func OrganizationFormFromMap(data interface{}) OrganizationForm {
	b, err := json.Marshal(data)
	if err == nil {
		return OrganizationFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func OrganizationFormFromJson(bytes io.Reader) OrganizationForm {
	var organizationForm OrganizationForm
	json.NewDecoder(bytes).Decode(&organizationForm)
	return organizationForm
}

type OrganizationSummary struct {
	Id  string `json:"id"`
	Key string `json:"key"`
}

func OrganizationSummaryFromMap(data interface{}) OrganizationSummary {
	b, err := json.Marshal(data)
	if err == nil {
		return OrganizationSummaryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func OrganizationSummaryFromJson(bytes io.Reader) OrganizationSummary {
	var organizationSummary OrganizationSummary
	json.NewDecoder(bytes).Decode(&organizationSummary)
	return organizationSummary
}

type Project struct {
	Id           string               `json:"id"`
	Organization OrganizationSummary  `json:"organization"`
	User         common.UserReference `json:"user"`
	Visibility   Visibility           `json:"visibility"`
	Scms         Scms                 `json:"scms"`
	Name         string               `json:"name"`
	Uri          string               `json:"uri"`
	Branch       string               `json:"branch"`
}

func ProjectFromMap(data interface{}) Project {
	b, err := json.Marshal(data)
	if err == nil {
		return ProjectFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ProjectFromJson(bytes io.Reader) Project {
	var project Project
	json.NewDecoder(bytes).Decode(&project)
	return project
}

type ProjectBinary struct {
	Id      string        `json:"id"`
	Project ProjectDetail `json:"project"`
	Name    string        `json:"name"`
	Version string        `json:"version"`
	Path    string        `json:"path"`
	Binary  Reference     `json:"binary,omitempty"`
}

func ProjectBinaryFromMap(data interface{}) ProjectBinary {
	b, err := json.Marshal(data)
	if err == nil {
		return ProjectBinaryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ProjectBinaryFromJson(bytes io.Reader) ProjectBinary {
	var projectBinary ProjectBinary
	json.NewDecoder(bytes).Decode(&projectBinary)
	return projectBinary
}

/**
 * Provides an ordered set of projects such that each set of projects is sure to
 * have its dependencies resolved. ie. when upgrading projects, you can efficiently
 * upgrade each set of projects in resolved togther.
 */
type ProjectDependencyResolution struct {
	Resolved   []ProjectDependencyResolutionResolved `json:"resolved"`
	Unresolved []ProjectUnresolvedSummary            `json:"unresolved"`
	Steps      map[string]string                     `json:"steps"`
}

func ProjectDependencyResolutionFromMap(data interface{}) ProjectDependencyResolution {
	b, err := json.Marshal(data)
	if err == nil {
		return ProjectDependencyResolutionFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ProjectDependencyResolutionFromJson(bytes io.Reader) ProjectDependencyResolution {
	var projectDependencyResolution ProjectDependencyResolution
	json.NewDecoder(bytes).Decode(&projectDependencyResolution)
	return projectDependencyResolution
}

type ProjectDependencyResolutionResolved struct {
	Projects []ProjectSummary `json:"projects"`
}

func ProjectDependencyResolutionResolvedFromMap(data interface{}) ProjectDependencyResolutionResolved {
	b, err := json.Marshal(data)
	if err == nil {
		return ProjectDependencyResolutionResolvedFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ProjectDependencyResolutionResolvedFromJson(bytes io.Reader) ProjectDependencyResolutionResolved {
	var projectDependencyResolutionResolved ProjectDependencyResolutionResolved
	json.NewDecoder(bytes).Decode(&projectDependencyResolutionResolved)
	return projectDependencyResolutionResolved
}

type ProjectDetail struct {
	Id           string              `json:"id"`
	Organization OrganizationSummary `json:"organization"`
	Name         string              `json:"name"`
}

func ProjectDetailFromMap(data interface{}) ProjectDetail {
	b, err := json.Marshal(data)
	if err == nil {
		return ProjectDetailFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ProjectDetailFromJson(bytes io.Reader) ProjectDetail {
	var projectDetail ProjectDetail
	json.NewDecoder(bytes).Decode(&projectDetail)
	return projectDetail
}

type ProjectForm struct {
	Organization string     `json:"organization"`
	Name         string     `json:"name"`
	Visibility   Visibility `json:"visibility"`
	Scms         Scms       `json:"scms"`
	Uri          string     `json:"uri"`
	Branch       string     `json:"branch"`
}

func ProjectFormFromMap(data interface{}) ProjectForm {
	b, err := json.Marshal(data)
	if err == nil {
		return ProjectFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ProjectFormFromJson(bytes io.Reader) ProjectForm {
	var projectForm ProjectForm
	json.NewDecoder(bytes).Decode(&projectForm)
	return projectForm
}

type ProjectLibrary struct {
	Id                string        `json:"id"`
	Project           ProjectDetail `json:"project"`
	GroupId           string        `json:"group_id"`
	ArtifactId        string        `json:"artifact_id"`
	Version           string        `json:"version"`
	CrossBuildVersion string        `json:"cross_build_version,omitempty"`
	Path              string        `json:"path"`
	Library           Reference     `json:"library,omitempty"`
}

func ProjectLibraryFromMap(data interface{}) ProjectLibrary {
	b, err := json.Marshal(data)
	if err == nil {
		return ProjectLibraryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ProjectLibraryFromJson(bytes io.Reader) ProjectLibrary {
	var projectLibrary ProjectLibrary
	json.NewDecoder(bytes).Decode(&projectLibrary)
	return projectLibrary
}

type ProjectPatchForm struct {
	Name       string     `json:"name,omitempty"`
	Visibility Visibility `json:"visibility,omitempty"`
	Scms       Scms       `json:"scms,omitempty"`
	Uri        string     `json:"uri,omitempty"`
	Branch     string     `json:"branch,omitempty"`
}

func ProjectPatchFormFromMap(data interface{}) ProjectPatchForm {
	b, err := json.Marshal(data)
	if err == nil {
		return ProjectPatchFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ProjectPatchFormFromJson(bytes io.Reader) ProjectPatchForm {
	var projectPatchForm ProjectPatchForm
	json.NewDecoder(bytes).Decode(&projectPatchForm)
	return projectPatchForm
}

type ProjectSummary struct {
	Id           string              `json:"id"`
	Organization OrganizationSummary `json:"organization"`
	Name         string              `json:"name"`
}

func ProjectSummaryFromMap(data interface{}) ProjectSummary {
	b, err := json.Marshal(data)
	if err == nil {
		return ProjectSummaryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ProjectSummaryFromJson(bytes io.Reader) ProjectSummary {
	var projectSummary ProjectSummary
	json.NewDecoder(bytes).Decode(&projectSummary)
	return projectSummary
}

type ProjectUnresolvedSummary struct {
	Project             ProjectSummary `json:"project"`
	ResolvedLibraries   []string       `json:"resolved_libraries"`
	UnresolvedLibraries []string       `json:"unresolved_libraries"`
}

func ProjectUnresolvedSummaryFromMap(data interface{}) ProjectUnresolvedSummary {
	b, err := json.Marshal(data)
	if err == nil {
		return ProjectUnresolvedSummaryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ProjectUnresolvedSummaryFromJson(bytes io.Reader) ProjectUnresolvedSummary {
	var projectUnresolvedSummary ProjectUnresolvedSummary
	json.NewDecoder(bytes).Decode(&projectUnresolvedSummary)
	return projectUnresolvedSummary
}

/**
 * Summary of a specific recommendations for a project. Designed for display in the
 * project dashboard
 */
type Recommendation struct {
	Id        string             `json:"id"`
	Project   ProjectDetail      `json:"project"`
	Type      RecommendationType `json:"type"`
	Object    Reference          `json:"object"`
	Name      string             `json:"name"`
	From      string             `json:"from"`
	To        string             `json:"to"`
	CreatedAt string             `json:"created_at"`
}

func RecommendationFromMap(data interface{}) Recommendation {
	b, err := json.Marshal(data)
	if err == nil {
		return RecommendationFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func RecommendationFromJson(bytes io.Reader) Recommendation {
	var recommendation Recommendation
	json.NewDecoder(bytes).Decode(&recommendation)
	return recommendation
}

type Reference struct {
	Id string `json:"id"`
}

func ReferenceFromMap(data interface{}) Reference {
	b, err := json.Marshal(data)
	if err == nil {
		return ReferenceFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ReferenceFromJson(bytes io.Reader) Reference {
	var reference Reference
	json.NewDecoder(bytes).Decode(&reference)
	return reference
}

type Repository struct {
	Name       string     `json:"name"`
	Visibility Visibility `json:"visibility"`
	Uri        string     `json:"uri"`
}

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 Resolver struct {
	Id           string              `json:"id"`
	Visibility   Visibility          `json:"visibility"`
	Organization OrganizationSummary `json:"organization,omitempty"`
	Uri          string              `json:"uri"`
	Credentials  Credentials         `json:"credentials,omitempty"`
}

func ResolverFromMap(data interface{}) Resolver {
	b, err := json.Marshal(data)
	if err == nil {
		return ResolverFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ResolverFromJson(bytes io.Reader) Resolver {
	var resolver Resolver
	json.NewDecoder(bytes).Decode(&resolver)
	return resolver
}

type ResolverForm struct {
	Visibility   Visibility  `json:"visibility"`
	Organization string      `json:"organization"`
	Uri          string      `json:"uri"`
	Credentials  Credentials `json:"credentials,omitempty"`
}

func ResolverFormFromMap(data interface{}) ResolverForm {
	b, err := json.Marshal(data)
	if err == nil {
		return ResolverFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ResolverFormFromJson(bytes io.Reader) ResolverForm {
	var resolverForm ResolverForm
	json.NewDecoder(bytes).Decode(&resolverForm)
	return resolverForm
}

type ResolverSummary struct {
	Id           string              `json:"id"`
	Organization OrganizationSummary `json:"organization,omitempty"`
	Visibility   Visibility          `json:"visibility"`
	Uri          string              `json:"uri"`
}

func ResolverSummaryFromMap(data interface{}) ResolverSummary {
	b, err := json.Marshal(data)
	if err == nil {
		return ResolverSummaryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ResolverSummaryFromJson(bytes io.Reader) ResolverSummary {
	var resolverSummary ResolverSummary
	json.NewDecoder(bytes).Decode(&resolverSummary)
	return resolverSummary
}

/**
 * Represents a user that is currently subscribed to a publication
 */
type Subscription struct {
	Id          string               `json:"id"`
	User        common.UserReference `json:"user"`
	Publication Publication          `json:"publication"`
}

func SubscriptionFromMap(data interface{}) Subscription {
	b, err := json.Marshal(data)
	if err == nil {
		return SubscriptionFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func SubscriptionFromJson(bytes io.Reader) Subscription {
	var subscription Subscription
	json.NewDecoder(bytes).Decode(&subscription)
	return subscription
}

type SubscriptionForm struct {
	UserId      string      `json:"user_id"`
	Publication Publication `json:"publication"`
}

func SubscriptionFormFromMap(data interface{}) SubscriptionForm {
	b, err := json.Marshal(data)
	if err == nil {
		return SubscriptionFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func SubscriptionFormFromJson(bytes io.Reader) SubscriptionForm {
	var subscriptionForm SubscriptionForm
	json.NewDecoder(bytes).Decode(&subscriptionForm)
	return subscriptionForm
}

/**
 * Records when we start and complete each sync of a module (e.g. project)
 */
type Sync struct {
	Id        string    `json:"id"`
	ObjectId  string    `json:"object_id"`
	Event     SyncEvent `json:"event"`
	CreatedAt string    `json:"created_at"`
}

func SyncFromMap(data interface{}) Sync {
	b, err := json.Marshal(data)
	if err == nil {
		return SyncFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func SyncFromJson(bytes io.Reader) Sync {
	var sync Sync
	json.NewDecoder(bytes).Decode(&sync)
	return sync
}

type TaskDataSync struct {
	Type SyncType `json:"type,omitempty"`
}

func TaskDataSyncFromMap(data interface{}) TaskDataSync {
	b, err := json.Marshal(data)
	if err == nil {
		return TaskDataSyncFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TaskDataSyncFromJson(bytes io.Reader) TaskDataSync {
	var taskDataSync TaskDataSync
	json.NewDecoder(bytes).Decode(&taskDataSync)
	return taskDataSync
}

type TaskDataSyncLibrariesByPrefix struct {
	UserId string `json:"user_id"`
	Prefix string `json:"prefix"`
}

func TaskDataSyncLibrariesByPrefixFromMap(data interface{}) TaskDataSyncLibrariesByPrefix {
	b, err := json.Marshal(data)
	if err == nil {
		return TaskDataSyncLibrariesByPrefixFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TaskDataSyncLibrariesByPrefixFromJson(bytes io.Reader) TaskDataSyncLibrariesByPrefix {
	var taskDataSyncLibrariesByPrefix TaskDataSyncLibrariesByPrefix
	json.NewDecoder(bytes).Decode(&taskDataSyncLibrariesByPrefix)
	return taskDataSyncLibrariesByPrefix
}

type TaskDataSyncOne struct {
	Id   string   `json:"id"`
	Type SyncType `json:"type"`
}

func TaskDataSyncOneFromMap(data interface{}) TaskDataSyncOne {
	b, err := json.Marshal(data)
	if err == nil {
		return TaskDataSyncOneFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TaskDataSyncOneFromJson(bytes io.Reader) TaskDataSyncOne {
	var taskDataSyncOne TaskDataSyncOne
	json.NewDecoder(bytes).Decode(&taskDataSyncOne)
	return taskDataSyncOne
}

type TaskDataSyncOrganizationLibraries struct {
	OrganizationId string `json:"organization_id"`
}

func TaskDataSyncOrganizationLibrariesFromMap(data interface{}) TaskDataSyncOrganizationLibraries {
	b, err := json.Marshal(data)
	if err == nil {
		return TaskDataSyncOrganizationLibrariesFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TaskDataSyncOrganizationLibrariesFromJson(bytes io.Reader) TaskDataSyncOrganizationLibraries {
	var taskDataSyncOrganizationLibraries TaskDataSyncOrganizationLibraries
	json.NewDecoder(bytes).Decode(&taskDataSyncOrganizationLibraries)
	return taskDataSyncOrganizationLibraries
}

/**
 * Represents that a new, for example, project was created or updated
 */
type TaskDataUpserted struct {
	Id   string   `json:"id"`
	Type SyncType `json:"type"`
}

func TaskDataUpsertedFromMap(data interface{}) TaskDataUpserted {
	b, err := json.Marshal(data)
	if err == nil {
		return TaskDataUpsertedFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TaskDataUpsertedFromJson(bytes io.Reader) TaskDataUpserted {
	var taskDataUpserted TaskDataUpserted
	json.NewDecoder(bytes).Decode(&taskDataUpserted)
	return taskDataUpserted
}

type Token struct {
	Id          string               `json:"id"`
	User        common.UserReference `json:"user"`
	Masked      string               `json:"masked"`
	Cleartext   string               `json:"cleartext,omitempty"`
	Description string               `json:"description,omitempty"`
}

func TokenFromMap(data interface{}) Token {
	b, err := json.Marshal(data)
	if err == nil {
		return TokenFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TokenFromJson(bytes io.Reader) Token {
	var token Token
	json.NewDecoder(bytes).Decode(&token)
	return token
}

type TokenForm struct {
	UserId      string `json:"user_id"`
	Description string `json:"description,omitempty"`
}

func TokenFormFromMap(data interface{}) TokenForm {
	b, err := json.Marshal(data)
	if err == nil {
		return TokenFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TokenFormFromJson(bytes io.Reader) TokenForm {
	var tokenForm TokenForm
	json.NewDecoder(bytes).Decode(&tokenForm)
	return tokenForm
}

type UserForm struct {
	Email string      `json:"email,omitempty"`
	Name  common.Name `json:"name,omitempty"`
}

func UserFormFromMap(data interface{}) UserForm {
	b, err := json.Marshal(data)
	if err == nil {
		return UserFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func UserFormFromJson(bytes io.Reader) UserForm {
	var userForm UserForm
	json.NewDecoder(bytes).Decode(&userForm)
	return userForm
}

type UserIdentifier struct {
	Id    string               `json:"id"`
	User  common.UserReference `json:"user"`
	Value string               `json:"value"`
}

func UserIdentifierFromMap(data interface{}) UserIdentifier {
	b, err := json.Marshal(data)
	if err == nil {
		return UserIdentifierFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func UserIdentifierFromJson(bytes io.Reader) UserIdentifier {
	var userIdentifier UserIdentifier
	json.NewDecoder(bytes).Decode(&userIdentifier)
	return userIdentifier
}

type UserSummary struct {
	Id    string      `json:"id"`
	Email string      `json:"email,omitempty"`
	Name  common.Name `json:"name"`
}

func UserSummaryFromMap(data interface{}) UserSummary {
	b, err := json.Marshal(data)
	if err == nil {
		return UserSummaryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func UserSummaryFromJson(bytes io.Reader) UserSummary {
	var userSummary UserSummary
	json.NewDecoder(bytes).Decode(&userSummary)
	return userSummary
}

type UsernamePassword struct {
	Username string `json:"username"`
	Password string `json:"password,omitempty"`
}

func UsernamePasswordFromMap(data interface{}) UsernamePassword {
	b, err := json.Marshal(data)
	if err == nil {
		return UsernamePasswordFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func UsernamePasswordFromJson(bytes io.Reader) UsernamePassword {
	var usernamePassword UsernamePassword
	json.NewDecoder(bytes).Decode(&usernamePassword)
	return usernamePassword
}

type VersionForm struct {
	Version           string `json:"version"`
	CrossBuildVersion string `json:"cross_build_version,omitempty"`
}

func VersionFormFromMap(data interface{}) VersionForm {
	b, err := json.Marshal(data)
	if err == nil {
		return VersionFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func VersionFormFromJson(bytes io.Reader) VersionForm {
	var versionForm VersionForm
	json.NewDecoder(bytes).Decode(&versionForm)
	return versionForm
}

type Credentials struct {
	UsernamePassword UsernamePassword
	Undefined        string
}

func CredentialsFromMap(data interface{}) Credentials {
	b, err := json.Marshal(data)
	if err == nil {
		return CredentialsFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func CredentialsFromJson(bytes io.Reader) Credentials {
	var el map[string]interface{}
	json.NewDecoder(bytes).Decode(&el)
	switch el["discriminator"] {
	case "username_password":
		return Credentials{UsernamePassword: UsernamePasswordFromMap(el)}
	default:
		return Credentials{Undefined: el["discriminator"].(string)}
	}
}

type ItemSummary struct {
	BinarySummary  BinarySummary
	LibrarySummary LibrarySummary
	ProjectSummary ProjectSummary
	Undefined      string
}

func ItemSummaryFromMap(data interface{}) ItemSummary {
	b, err := json.Marshal(data)
	if err == nil {
		return ItemSummaryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ItemSummaryFromJson(bytes io.Reader) ItemSummary {
	var el map[string]interface{}
	json.NewDecoder(bytes).Decode(&el)
	switch el["discriminator"] {
	case "binary_summary":
		return ItemSummary{BinarySummary: BinarySummaryFromMap(el)}
	case "library_summary":
		return ItemSummary{LibrarySummary: LibrarySummaryFromMap(el)}
	case "project_summary":
		return ItemSummary{ProjectSummary: ProjectSummaryFromMap(el)}
	default:
		return ItemSummary{Undefined: el["discriminator"].(string)}
	}
}

type TaskData struct {
	TaskDataUpserted                  TaskDataUpserted
	TaskDataSync                      TaskDataSync
	TaskDataSyncOne                   TaskDataSyncOne
	TaskDataSyncLibrariesByPrefix     TaskDataSyncLibrariesByPrefix
	TaskDataSyncOrganizationLibraries TaskDataSyncOrganizationLibraries
	Undefined                         string
}

func TaskDataFromMap(data interface{}) TaskData {
	b, err := json.Marshal(data)
	if err == nil {
		return TaskDataFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TaskDataFromJson(bytes io.Reader) TaskData {
	var el map[string]interface{}
	json.NewDecoder(bytes).Decode(&el)
	switch el["discriminator"] {
	case "task_data_upserted":
		return TaskData{TaskDataUpserted: TaskDataUpsertedFromMap(el)}
	case "task_data_sync":
		return TaskData{TaskDataSync: TaskDataSyncFromMap(el)}
	case "task_data_sync_one":
		return TaskData{TaskDataSyncOne: TaskDataSyncOneFromMap(el)}
	case "task_data_sync_libraries_by_prefix":
		return TaskData{TaskDataSyncLibrariesByPrefix: TaskDataSyncLibrariesByPrefixFromMap(el)}
	case "task_data_sync_organization_libraries":
		return TaskData{TaskDataSyncOrganizationLibraries: TaskDataSyncOrganizationLibrariesFromMap(el)}
	default:
		return TaskData{Undefined: el["discriminator"].(string)}
	}
}

type BinariesGetParams struct {
	Id        string
	Ids       []string
	ProjectId string
	Name      string
	Limit     int64
	Offset    int64
}

type BinariesGetResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Binaries   []Binary
}

func BinariesGet(client Client, params BinariesGetParams) BinariesGetResponse {

	requestUrl := fmt.Sprintf("%s/binaries", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Id {
		urlValues.Add("id", params.Id)
	}
	for _, value := range params.Ids {
		urlValues.Add("ids", value)
	}
	if "" != params.ProjectId {
		urlValues.Add("project_id", params.ProjectId)
	}
	if "" != params.Name {
		urlValues.Add("name", params.Name)
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}

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

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

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

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

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

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

}

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

func BinariesGetById(client Client, id string) BinariesGetByIdResponse {

	requestUrl := fmt.Sprintf("%s/binaries/%s", client.BaseUrl, html.EscapeString(id))

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

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

	switch resp.StatusCode {
	case 200:
		return BinariesGetByIdResponse{StatusCode: resp.StatusCode, Response: resp, Binary: BinaryFromJson(resp.Body)}

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

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

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

}

type BinariesPostResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	Binary            Binary
	ErrorGenericError error_.GenericError
}

func BinariesPost(client Client, binaryForm BinaryForm) BinariesPostResponse {

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

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

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

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

	switch resp.StatusCode {
	case 201:
		return BinariesPostResponse{StatusCode: resp.StatusCode, Response: resp, Binary: BinaryFromJson(resp.Body)}

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

	case 422:
		return BinariesPostResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type BinariesDeleteByIdResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
}

func BinariesDeleteById(client Client, id string) BinariesDeleteByIdResponse {

	requestUrl := fmt.Sprintf("%s/binaries/%s", client.BaseUrl, html.EscapeString(id))

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

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

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

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

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

	case 422:
		return BinariesDeleteByIdResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type BinaryVersionsGetParams struct {
	Id        string
	Ids       []string
	BinaryId  string
	ProjectId string
	Limit     int64
	Offset    int64
}

type BinaryVersionsGetResponse struct {
	StatusCode     int
	Response       *http.Response
	Error          error
	BinaryVersions []BinaryVersion
}

func BinaryVersionsGet(client Client, params BinaryVersionsGetParams) BinaryVersionsGetResponse {

	requestUrl := fmt.Sprintf("%s/binary_versions", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Id {
		urlValues.Add("id", params.Id)
	}
	for _, value := range params.Ids {
		urlValues.Add("ids", value)
	}
	if "" != params.BinaryId {
		urlValues.Add("binary_id", params.BinaryId)
	}
	if "" != params.ProjectId {
		urlValues.Add("project_id", params.ProjectId)
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}

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

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

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

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

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

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

}

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

func BinaryVersionsGetById(client Client, id string) BinaryVersionsGetByIdResponse {

	requestUrl := fmt.Sprintf("%s/binary_versions/%s", client.BaseUrl, html.EscapeString(id))

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

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

	switch resp.StatusCode {
	case 200:
		return BinaryVersionsGetByIdResponse{StatusCode: resp.StatusCode, Response: resp, BinaryVersion: BinaryVersionFromJson(resp.Body)}

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

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

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

}

type GithubUsersPostGithubResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	CommonUser        common.User
	ErrorGenericError error_.GenericError
}

func GithubUsersPostGithub(client Client, githubAuthenticationForm GithubAuthenticationForm) GithubUsersPostGithubResponse {

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

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

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

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

	switch resp.StatusCode {
	case 200:
		return GithubUsersPostGithubResponse{StatusCode: resp.StatusCode, Response: resp, CommonUser: common.UserFromJson(resp.Body)}

	case 422:
		return GithubUsersPostGithubResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

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

func GithubWebhooksPostByProjectId(client Client, projectId string) GithubWebhooksPostByProjectIdResponse {

	requestUrl := fmt.Sprintf("%s/webhooks/github/%s", client.BaseUrl, html.EscapeString(projectId))

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

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

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

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

}

type UsersGetParams struct {
	Id         string
	Email      string
	Identifier string
}

type UsersGetResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	CommonUsers       []common.User
	ErrorGenericError error_.GenericError
}

func UsersGet(client Client, params UsersGetParams) UsersGetResponse {

	requestUrl := fmt.Sprintf("%s/users", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Id {
		urlValues.Add("id", params.Id)
	}
	if "" != params.Email {
		urlValues.Add("email", params.Email)
	}
	if "" != params.Identifier {
		urlValues.Add("identifier", params.Identifier)
	}

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

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

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

	switch resp.StatusCode {
	case 200:
		return UsersGetResponse{StatusCode: resp.StatusCode, Response: resp, CommonUsers: func() []common.User {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []common.User
			for _, el := range tmp {
				all = append(all, common.UserFromMap(el))
			}
			return all
		}()}

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

	case 422:
		return UsersGetResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type UsersGetByIdResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	CommonUser common.User
}

func UsersGetById(client Client, id string) UsersGetByIdResponse {

	requestUrl := fmt.Sprintf("%s/users/%s", client.BaseUrl, html.EscapeString(id))

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

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

	switch resp.StatusCode {
	case 200:
		return UsersGetByIdResponse{StatusCode: resp.StatusCode, Response: resp, CommonUser: common.UserFromJson(resp.Body)}

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

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

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

}

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

func UsersGetIdentifierById(client Client, id string) UsersGetIdentifierByIdResponse {

	requestUrl := fmt.Sprintf("%s/users/%s/identifier", client.BaseUrl, html.EscapeString(id))

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

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

	switch resp.StatusCode {
	case 200:
		return UsersGetIdentifierByIdResponse{StatusCode: resp.StatusCode, Response: resp, UserIdentifier: UserIdentifierFromJson(resp.Body)}

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

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

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

}

type UsersPostResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	CommonUser        common.User
	ErrorGenericError error_.GenericError
}

func UsersPost(client Client, userForm UserForm) UsersPostResponse {

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

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

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

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

	switch resp.StatusCode {
	case 201:
		return UsersPostResponse{StatusCode: resp.StatusCode, Response: resp, CommonUser: common.UserFromJson(resp.Body)}

	case 422:
		return UsersPostResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type HealthchecksGetHealthcheckResponse struct {
	StatusCode             int
	Response               *http.Response
	Error                  error
	HealthcheckHealthcheck healthcheck.Healthcheck
}

func HealthchecksGetHealthcheck(client Client) HealthchecksGetHealthcheckResponse {

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

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

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

	switch resp.StatusCode {
	case 200:
		return HealthchecksGetHealthcheckResponse{StatusCode: resp.StatusCode, Response: resp, HealthcheckHealthcheck: healthcheck.HealthcheckFromJson(resp.Body)}

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

}

type ItemsGetParams struct {
	Q      string
	Limit  int64
	Offset int64
}

type ItemsGetResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Items      []Item
}

func ItemsGet(client Client, params ItemsGetParams) ItemsGetResponse {

	requestUrl := fmt.Sprintf("%s/items", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Q {
		urlValues.Add("q", params.Q)
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}

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

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

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

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

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

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

}

type LibrariesGetParams struct {
	Id         string
	Ids        []string
	ProjectId  string
	GroupId    string
	ArtifactId string
	ResolverId string
	Limit      int64
	Offset     int64
}

type LibrariesGetResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Libraries  []Library
}

func LibrariesGet(client Client, params LibrariesGetParams) LibrariesGetResponse {

	requestUrl := fmt.Sprintf("%s/libraries", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Id {
		urlValues.Add("id", params.Id)
	}
	for _, value := range params.Ids {
		urlValues.Add("ids", value)
	}
	if "" != params.ProjectId {
		urlValues.Add("project_id", params.ProjectId)
	}
	if "" != params.GroupId {
		urlValues.Add("group_id", params.GroupId)
	}
	if "" != params.ArtifactId {
		urlValues.Add("artifact_id", params.ArtifactId)
	}
	if "" != params.ResolverId {
		urlValues.Add("resolver_id", params.ResolverId)
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}

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

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

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

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

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

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

}

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

func LibrariesGetById(client Client, id string) LibrariesGetByIdResponse {

	requestUrl := fmt.Sprintf("%s/libraries/%s", client.BaseUrl, html.EscapeString(id))

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

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

	switch resp.StatusCode {
	case 200:
		return LibrariesGetByIdResponse{StatusCode: resp.StatusCode, Response: resp, Library: LibraryFromJson(resp.Body)}

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

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

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

}

type LibrariesPostResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
	Library           Library
}

func LibrariesPost(client Client, libraryForm LibraryForm) LibrariesPostResponse {

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

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

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

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

	switch resp.StatusCode {
	case 201:
		return LibrariesPostResponse{StatusCode: resp.StatusCode, Response: resp, Library: LibraryFromJson(resp.Body)}

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

	case 422:
		return LibrariesPostResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type LibrariesDeleteByIdResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
}

func LibrariesDeleteById(client Client, id string) LibrariesDeleteByIdResponse {

	requestUrl := fmt.Sprintf("%s/libraries/%s", client.BaseUrl, html.EscapeString(id))

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

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

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

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

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

	case 422:
		return LibrariesDeleteByIdResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type LibraryVersionsGetParams struct {
	Id        string
	Ids       []string
	LibraryId string
	Limit     int64
	Offset    int64
}

type LibraryVersionsGetResponse struct {
	StatusCode      int
	Response        *http.Response
	Error           error
	LibraryVersions []LibraryVersion
}

func LibraryVersionsGet(client Client, params LibraryVersionsGetParams) LibraryVersionsGetResponse {

	requestUrl := fmt.Sprintf("%s/library_versions", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Id {
		urlValues.Add("id", params.Id)
	}
	for _, value := range params.Ids {
		urlValues.Add("ids", value)
	}
	if "" != params.LibraryId {
		urlValues.Add("library_id", params.LibraryId)
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}

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

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

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

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

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

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

}

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

func LibraryVersionsGetById(client Client, id string) LibraryVersionsGetByIdResponse {

	requestUrl := fmt.Sprintf("%s/library_versions/%s", client.BaseUrl, html.EscapeString(id))

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

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

	switch resp.StatusCode {
	case 200:
		return LibraryVersionsGetByIdResponse{StatusCode: resp.StatusCode, Response: resp, LibraryVersion: LibraryVersionFromJson(resp.Body)}

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

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

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

}

type MembershipsGetParams struct {
	Id           string
	Ids          []string
	Organization string
	UserId       string
	Role         Role
	Limit        int64
	Offset       int64
}

type MembershipsGetResponse struct {
	StatusCode  int
	Response    *http.Response
	Error       error
	Memberships []Membership
}

func MembershipsGet(client Client, params MembershipsGetParams) MembershipsGetResponse {

	requestUrl := fmt.Sprintf("%s/memberships", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Id {
		urlValues.Add("id", params.Id)
	}
	for _, value := range params.Ids {
		urlValues.Add("ids", value)
	}
	if "" != params.Organization {
		urlValues.Add("organization", params.Organization)
	}
	if "" != params.UserId {
		urlValues.Add("user_id", params.UserId)
	}
	if "" != params.Role {
		urlValues.Add("role", string(params.Role))
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}

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

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

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

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

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

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

}

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

func MembershipsGetById(client Client, id string) MembershipsGetByIdResponse {

	requestUrl := fmt.Sprintf("%s/memberships/%s", client.BaseUrl, html.EscapeString(id))

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

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

	switch resp.StatusCode {
	case 200:
		return MembershipsGetByIdResponse{StatusCode: resp.StatusCode, Response: resp, Membership: MembershipFromJson(resp.Body)}

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

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

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

}

type MembershipsPostResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
	Membership        Membership
}

func MembershipsPost(client Client, membershipForm MembershipForm) MembershipsPostResponse {

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


	if "" == membershipForm.Role {
		membershipForm.Role = RoleFromString("member")
	}

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

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

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

	switch resp.StatusCode {
	case 201:
		return MembershipsPostResponse{StatusCode: resp.StatusCode, Response: resp, Membership: MembershipFromJson(resp.Body)}

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

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

	case 422:
		return MembershipsPostResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type MembershipsDeleteByIdResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
}

func MembershipsDeleteById(client Client, id string) MembershipsDeleteByIdResponse {

	requestUrl := fmt.Sprintf("%s/memberships/%s", client.BaseUrl, html.EscapeString(id))

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

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

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

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

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

	case 422:
		return MembershipsDeleteByIdResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type OrganizationsGetParams struct {
	Id     string
	Ids    []string
	UserId string
	Key    string
	Limit  int64
	Offset int64
}

type OrganizationsGetResponse struct {
	StatusCode    int
	Response      *http.Response
	Error         error
	Organizations []Organization
}

func OrganizationsGet(client Client, params OrganizationsGetParams) OrganizationsGetResponse {

	requestUrl := fmt.Sprintf("%s/organizations", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Id {
		urlValues.Add("id", params.Id)
	}
	for _, value := range params.Ids {
		urlValues.Add("ids", value)
	}
	if "" != params.UserId {
		urlValues.Add("user_id", params.UserId)
	}
	if "" != params.Key {
		urlValues.Add("key", params.Key)
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}

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

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

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

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

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

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

}

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

func OrganizationsGetUsersByUserId(client Client, userId string) OrganizationsGetUsersByUserIdResponse {

	requestUrl := fmt.Sprintf("%s/organizations/users/%s", client.BaseUrl, html.EscapeString(userId))

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

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

	switch resp.StatusCode {
	case 200:
		return OrganizationsGetUsersByUserIdResponse{StatusCode: resp.StatusCode, Response: resp, Organization: OrganizationFromJson(resp.Body)}

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

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

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

}

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

func OrganizationsGetById(client Client, id string) OrganizationsGetByIdResponse {

	requestUrl := fmt.Sprintf("%s/organizations/%s", client.BaseUrl, html.EscapeString(id))

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

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

	switch resp.StatusCode {
	case 200:
		return OrganizationsGetByIdResponse{StatusCode: resp.StatusCode, Response: resp, Organization: OrganizationFromJson(resp.Body)}

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

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

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

}

type OrganizationsPostResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
	Organization      Organization
}

func OrganizationsPost(client Client, organizationForm OrganizationForm) OrganizationsPostResponse {

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

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

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

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

	switch resp.StatusCode {
	case 201:
		return OrganizationsPostResponse{StatusCode: resp.StatusCode, Response: resp, Organization: OrganizationFromJson(resp.Body)}

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

	case 422:
		return OrganizationsPostResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type OrganizationsPutByIdResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
	Organization      Organization
}

func OrganizationsPutById(client Client, id string, organizationForm OrganizationForm) OrganizationsPutByIdResponse {

	requestUrl := fmt.Sprintf("%s/organizations/%s", client.BaseUrl, html.EscapeString(id))

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

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

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

	switch resp.StatusCode {
	case 200:
		return OrganizationsPutByIdResponse{StatusCode: resp.StatusCode, Response: resp, Organization: OrganizationFromJson(resp.Body)}

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

	case 422:
		return OrganizationsPutByIdResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type OrganizationsDeleteByIdResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
}

func OrganizationsDeleteById(client Client, id string) OrganizationsDeleteByIdResponse {

	requestUrl := fmt.Sprintf("%s/organizations/%s", client.BaseUrl, html.EscapeString(id))

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

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

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

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

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

	case 422:
		return OrganizationsDeleteByIdResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type ProjectsGetParams struct {
	Id           string
	Ids          []string
	Organization string
	Name         string
	GroupId      string
	ArtifactId   string
	Version      string
	LibraryId    string
	Binary       string
	BinaryId     string
	Limit        int64
	Offset       int64
}

type ProjectsGetResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Projects   []Project
}

func ProjectsGet(client Client, params ProjectsGetParams) ProjectsGetResponse {

	requestUrl := fmt.Sprintf("%s/projects", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Id {
		urlValues.Add("id", params.Id)
	}
	for _, value := range params.Ids {
		urlValues.Add("ids", value)
	}
	if "" != params.Organization {
		urlValues.Add("organization", params.Organization)
	}
	if "" != params.Name {
		urlValues.Add("name", params.Name)
	}
	if "" != params.GroupId {
		urlValues.Add("group_id", params.GroupId)
	}
	if "" != params.ArtifactId {
		urlValues.Add("artifact_id", params.ArtifactId)
	}
	if "" != params.Version {
		urlValues.Add("version", params.Version)
	}
	if "" != params.LibraryId {
		urlValues.Add("library_id", params.LibraryId)
	}
	if "" != params.Binary {
		urlValues.Add("binary", params.Binary)
	}
	if "" != params.BinaryId {
		urlValues.Add("binary_id", params.BinaryId)
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}

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

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

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

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

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

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

}

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

func ProjectsGetById(client Client, id string) ProjectsGetByIdResponse {

	requestUrl := fmt.Sprintf("%s/projects/%s", client.BaseUrl, html.EscapeString(id))

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

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

	switch resp.StatusCode {
	case 200:
		return ProjectsGetByIdResponse{StatusCode: resp.StatusCode, Response: resp, Project: ProjectFromJson(resp.Body)}

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

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

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

}

type ProjectsPostResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
	Project           Project
}

func ProjectsPost(client Client, projectForm ProjectForm) ProjectsPostResponse {

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

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

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

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

	switch resp.StatusCode {
	case 201:
		return ProjectsPostResponse{StatusCode: resp.StatusCode, Response: resp, Project: ProjectFromJson(resp.Body)}

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

	case 422:
		return ProjectsPostResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type ProjectsPutByIdResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
	Project           Project
}

func ProjectsPutById(client Client, id string, projectForm ProjectForm) ProjectsPutByIdResponse {

	requestUrl := fmt.Sprintf("%s/projects/%s", client.BaseUrl, html.EscapeString(id))

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

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

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

	switch resp.StatusCode {
	case 200:
		return ProjectsPutByIdResponse{StatusCode: resp.StatusCode, Response: resp, Project: ProjectFromJson(resp.Body)}

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

	case 422:
		return ProjectsPutByIdResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type ProjectsPatchByIdResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
	Project           Project
}

func ProjectsPatchById(client Client, id string, projectPatchForm ProjectPatchForm) ProjectsPatchByIdResponse {

	requestUrl := fmt.Sprintf("%s/projects/%s", client.BaseUrl, html.EscapeString(id))

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

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

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

	switch resp.StatusCode {
	case 200:
		return ProjectsPatchByIdResponse{StatusCode: resp.StatusCode, Response: resp, Project: ProjectFromJson(resp.Body)}

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

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

	case 422:
		return ProjectsPatchByIdResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type ProjectsDeleteByIdResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
}

func ProjectsDeleteById(client Client, id string) ProjectsDeleteByIdResponse {

	requestUrl := fmt.Sprintf("%s/projects/%s", client.BaseUrl, html.EscapeString(id))

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

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

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

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

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

	case 422:
		return ProjectsDeleteByIdResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type ProjectBinariesGetParams struct {
	Id        string
	Ids       []string
	ProjectId string
	BinaryId  string
	IsSynced  string
	Limit     int64
	Offset    int64
}

type ProjectBinariesGetResponse struct {
	StatusCode      int
	Response        *http.Response
	Error           error
	ProjectBinaries []ProjectBinary
}

func ProjectBinariesGet(client Client, params ProjectBinariesGetParams) ProjectBinariesGetResponse {

	requestUrl := fmt.Sprintf("%s/project_binaries", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Id {
		urlValues.Add("id", params.Id)
	}
	for _, value := range params.Ids {
		urlValues.Add("ids", value)
	}
	if "" != params.ProjectId {
		urlValues.Add("project_id", params.ProjectId)
	}
	if "" != params.BinaryId {
		urlValues.Add("binary_id", params.BinaryId)
	}
	if "" != params.IsSynced {
		urlValues.Add("is_synced", params.IsSynced)
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}

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

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

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

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

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

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

}

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

func ProjectDependencyResolutionsGet(client Client, organization string, groupId string) ProjectDependencyResolutionsGetResponse {

	requestUrl := fmt.Sprintf("%s/%s/project/dependencies/group/%s", client.BaseUrl, html.EscapeString(organization), html.EscapeString(groupId))

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

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

	switch resp.StatusCode {
	case 200:
		return ProjectDependencyResolutionsGetResponse{StatusCode: resp.StatusCode, Response: resp, ProjectDependencyResolution: ProjectDependencyResolutionFromJson(resp.Body)}

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

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

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

}

type ProjectLibrariesGetParams struct {
	Id        string
	Ids       []string
	ProjectId string
	LibraryId string
	IsSynced  string
	Limit     int64
	Offset    int64
}

type ProjectLibrariesGetResponse struct {
	StatusCode       int
	Response         *http.Response
	Error            error
	ProjectLibraries []ProjectLibrary
}

func ProjectLibrariesGet(client Client, params ProjectLibrariesGetParams) ProjectLibrariesGetResponse {

	requestUrl := fmt.Sprintf("%s/project_libraries", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Id {
		urlValues.Add("id", params.Id)
	}
	for _, value := range params.Ids {
		urlValues.Add("ids", value)
	}
	if "" != params.ProjectId {
		urlValues.Add("project_id", params.ProjectId)
	}
	if "" != params.LibraryId {
		urlValues.Add("library_id", params.LibraryId)
	}
	if "" != params.IsSynced {
		urlValues.Add("is_synced", params.IsSynced)
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}

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

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

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

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

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

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

}

type RecommendationsGetParams struct {
	Organization string
	ProjectId    string
	Type         RecommendationType
	Limit        int64
	Offset       int64
}

type RecommendationsGetResponse struct {
	StatusCode      int
	Response        *http.Response
	Error           error
	Recommendations []Recommendation
}

func RecommendationsGet(client Client, params RecommendationsGetParams) RecommendationsGetResponse {

	requestUrl := fmt.Sprintf("%s/recommendations", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Organization {
		urlValues.Add("organization", params.Organization)
	}
	if "" != params.ProjectId {
		urlValues.Add("project_id", params.ProjectId)
	}
	if "" != params.Type {
		urlValues.Add("type", string(params.Type))
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}

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

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

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

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

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

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

}

type RepositoriesGetGithubParams struct {
	Owner           string
	Name            string
	OrganizationId  string
	ExistingProject string
	Limit           int64
	Offset          int64
}

type RepositoriesGetGithubResponse struct {
	StatusCode         int
	Response           *http.Response
	Error              error
	ErrorGenericError  error_.GenericError
	GithubRepositories []github.Repository
}

func RepositoriesGetGithub(client Client, params RepositoriesGetGithubParams) RepositoriesGetGithubResponse {

	requestUrl := fmt.Sprintf("%s/repositories/github", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Owner {
		urlValues.Add("owner", params.Owner)
	}
	if "" != params.Name {
		urlValues.Add("name", params.Name)
	}
	if "" != params.OrganizationId {
		urlValues.Add("organization_id", params.OrganizationId)
	}
	if "" != params.ExistingProject {
		urlValues.Add("existing_project", params.ExistingProject)
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}

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

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

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

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

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

	case 422:
		return RepositoriesGetGithubResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type ResolversGetParams struct {
	Id           string
	Ids          []string
	Organization string
	Visibility   Visibility
	Limit        int64
	Offset       int64
}

type ResolversGetResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Resolvers  []Resolver
}

func ResolversGet(client Client, params ResolversGetParams) ResolversGetResponse {

	requestUrl := fmt.Sprintf("%s/resolvers", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Id {
		urlValues.Add("id", params.Id)
	}
	for _, value := range params.Ids {
		urlValues.Add("ids", value)
	}
	if "" != params.Organization {
		urlValues.Add("organization", params.Organization)
	}
	if "" != params.Visibility {
		urlValues.Add("visibility", string(params.Visibility))
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}

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

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

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

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

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

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

}

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

func ResolversGetById(client Client, id string) ResolversGetByIdResponse {

	requestUrl := fmt.Sprintf("%s/resolvers/%s", client.BaseUrl, html.EscapeString(id))

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

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

	switch resp.StatusCode {
	case 200:
		return ResolversGetByIdResponse{StatusCode: resp.StatusCode, Response: resp, Resolver: ResolverFromJson(resp.Body)}

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

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

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

}

type ResolversPostResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
	Resolver          Resolver
}

func ResolversPost(client Client, resolverForm ResolverForm) ResolversPostResponse {

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

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

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

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

	switch resp.StatusCode {
	case 201:
		return ResolversPostResponse{StatusCode: resp.StatusCode, Response: resp, Resolver: ResolverFromJson(resp.Body)}

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

	case 422:
		return ResolversPostResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type ResolversDeleteByIdResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
}

func ResolversDeleteById(client Client, id string) ResolversDeleteByIdResponse {

	requestUrl := fmt.Sprintf("%s/resolvers/%s", client.BaseUrl, html.EscapeString(id))

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

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

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

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

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

	case 422:
		return ResolversDeleteByIdResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type SubscriptionsGetParams struct {
	Id          string
	Ids         []string
	UserId      string
	Identifier  string
	Publication Publication
	Limit       int64
	Offset      int64
}

type SubscriptionsGetResponse struct {
	StatusCode    int
	Response      *http.Response
	Error         error
	Subscriptions []Subscription
}

func SubscriptionsGet(client Client, params SubscriptionsGetParams) SubscriptionsGetResponse {

	requestUrl := fmt.Sprintf("%s/subscriptions", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Id {
		urlValues.Add("id", params.Id)
	}
	for _, value := range params.Ids {
		urlValues.Add("ids", value)
	}
	if "" != params.UserId {
		urlValues.Add("user_id", params.UserId)
	}
	if "" != params.Identifier {
		urlValues.Add("identifier", params.Identifier)
	}
	if "" != params.Publication {
		urlValues.Add("publication", string(params.Publication))
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}

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

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

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

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

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

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

}

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

func SubscriptionsGetById(client Client, id string) SubscriptionsGetByIdResponse {

	requestUrl := fmt.Sprintf("%s/subscriptions/%s", client.BaseUrl, html.EscapeString(id))

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

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

	switch resp.StatusCode {
	case 200:
		return SubscriptionsGetByIdResponse{StatusCode: resp.StatusCode, Response: resp, Subscription: SubscriptionFromJson(resp.Body)}

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

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

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

}

type SubscriptionsPostParams struct {
	Identifier string
}

type SubscriptionsPostResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
	Subscription      Subscription
}

func SubscriptionsPost(client Client, params SubscriptionsPostParams, subscriptionForm SubscriptionForm) SubscriptionsPostResponse {

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

	bodyDocument, err := json.Marshal(subscriptionForm)
	if err != nil {
		return SubscriptionsPostResponse{Error: err}
	}
	body := ClientRequestBody{contentType: "application/json", bytes: bytes.NewReader(bodyDocument)}
	urlValues := url.Values{}
	if "" != params.Identifier {
		urlValues.Add("identifier", params.Identifier)
	}

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

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

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

	switch resp.StatusCode {
	case 201:
		return SubscriptionsPostResponse{StatusCode: resp.StatusCode, Response: resp, Subscription: SubscriptionFromJson(resp.Body)}

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

	case 422:
		return SubscriptionsPostResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type SubscriptionsDeleteByIdParams struct {
	Identifier string
}

type SubscriptionsDeleteByIdResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
}

func SubscriptionsDeleteById(client Client, id string, params SubscriptionsDeleteByIdParams) SubscriptionsDeleteByIdResponse {

	requestUrl := fmt.Sprintf("%s/subscriptions/%s", client.BaseUrl, html.EscapeString(id))
	urlValues := url.Values{}
	if "" != params.Identifier {
		urlValues.Add("identifier", params.Identifier)
	}

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

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

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

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

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

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

	case 422:
		return SubscriptionsDeleteByIdResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type SyncsGetParams struct {
	ObjectId string
	Event    SyncEvent
	Limit    int64
	Offset   int64
}

type SyncsGetResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Syncs      []Sync
}

func SyncsGet(client Client, params SyncsGetParams) SyncsGetResponse {

	requestUrl := fmt.Sprintf("%s/syncs", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.ObjectId {
		urlValues.Add("object_id", params.ObjectId)
	}
	if "" != params.Event {
		urlValues.Add("event", string(params.Event))
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}

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

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

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

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

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

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

}

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

func SyncsPostLibrariesByOrganization(client Client, organization string) SyncsPostLibrariesByOrganizationResponse {

	requestUrl := fmt.Sprintf("%s/syncs/%s/libraries", client.BaseUrl, html.EscapeString(organization))

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

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

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

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

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

}

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

func SyncsPostBinariesById(client Client, id string) SyncsPostBinariesByIdResponse {

	requestUrl := fmt.Sprintf("%s/syncs/binaries/%s", client.BaseUrl, html.EscapeString(id))

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

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

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

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

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

}

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

func SyncsPostLibrariesAndPrefixByArtifactIdPrefix(client Client, artifactIdPrefix string) SyncsPostLibrariesAndPrefixByArtifactIdPrefixResponse {

	requestUrl := fmt.Sprintf("%s/syncs/libraries/prefix/%s", client.BaseUrl, html.EscapeString(artifactIdPrefix))

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

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

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

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

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

}

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

func SyncsPostLibrariesById(client Client, id string) SyncsPostLibrariesByIdResponse {

	requestUrl := fmt.Sprintf("%s/syncs/libraries/%s", client.BaseUrl, html.EscapeString(id))

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

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

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

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

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

}

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

func SyncsPostProjectsById(client Client, id string) SyncsPostProjectsByIdResponse {

	requestUrl := fmt.Sprintf("%s/syncs/projects/%s", client.BaseUrl, html.EscapeString(id))

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

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

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

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

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

}

type TokensGetParams struct {
	Id     []string
	UserId string
	Limit  int64
	Offset int64
}

type TokensGetResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Tokens     []Token
}

func TokensGet(client Client, params TokensGetParams) TokensGetResponse {

	requestUrl := fmt.Sprintf("%s/tokens", client.BaseUrl)
	urlValues := url.Values{}
	for _, value := range params.Id {
		urlValues.Add("id", value)
	}
	if "" != params.UserId {
		urlValues.Add("user_id", params.UserId)
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}

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

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

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

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

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

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

}

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

func TokensGetById(client Client, id string) TokensGetByIdResponse {

	requestUrl := fmt.Sprintf("%s/tokens/%s", client.BaseUrl, html.EscapeString(id))

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

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

	switch resp.StatusCode {
	case 200:
		return TokensGetByIdResponse{StatusCode: resp.StatusCode, Response: resp, Token: TokenFromJson(resp.Body)}

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

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

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

}

type TokensPostResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
	Token             Token
}

func TokensPost(client Client, tokenForm TokenForm) TokensPostResponse {

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

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

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

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

	switch resp.StatusCode {
	case 201:
		return TokensPostResponse{StatusCode: resp.StatusCode, Response: resp, Token: TokenFromJson(resp.Body)}

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

	case 422:
		return TokensPostResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

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

}

type TokensDeleteByIdResponse struct {
	StatusCode        int
	Response          *http.Response
	Error             error
	ErrorGenericError error_.GenericError
}

func TokensDeleteById(client Client, id string) TokensDeleteByIdResponse {

	requestUrl := fmt.Sprintf("%s/tokens/%s", client.BaseUrl, html.EscapeString(id))

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

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

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

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

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

	case 422:
		return TokensDeleteByIdResponse{StatusCode: resp.StatusCode, Response: resp, ErrorGenericError: error_.GenericErrorFromJson(resp.Body)}

	default:
		return TokensDeleteByIdResponse{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.Add("User-Agent",             UserAgent)
	request.Header.Add("X-Apidoc-Version",       Version)
	request.Header.Add("X-Apidoc-Version-Major", strconv.Itoa(VersionMajor))

	if client.Headers != nil {
		for key, values := range client.Headers {
			for _, value := range values {
				request.Header.Add(key, value)
			}
		}
	}

	if body.contentType != "" {
		request.Header.Add("Content-Type", body.contentType)
	}

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

	return request, nil

}