package apibuilderpostmancollectionv21

/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.16.74
 * User agent: apibuilder app.apibuilder.io/apicollective/apibuilder-postman-collection-v2-1/0.16.74/go_1_5_client
 */

import (
	"bytes"
	"encoding/json"
	"io"
	"strings"
)

const BaseUrl = "https://www.getpostman.com"
const UserAgent = "apibuilder app.apibuilder.io/apicollective/apibuilder-postman-collection-v2-1/0.16.74/go_1_5_client"
const Version = "0.16.74"
const VersionMajor = 0

type AuthEnum string

const (
	AuthEnumAwsv4 AuthEnum  = "awsv4"
	AuthEnumBasic           = "basic"
	AuthEnumBearer          = "bearer"
	AuthEnumDigest          = "digest"
	AuthEnumHawk            = "hawk"
	AuthEnumNoauth          = "noauth"
	AuthEnumOauth1          = "oauth1"
	AuthEnumOauth2          = "oauth2"
	AuthEnumNtlm            = "ntlm"
	AuthEnumUNDEFINED       = "UNDEFINED"
)

func AuthEnumFromString(value string) AuthEnum {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "awsv4":
		return AuthEnumAwsv4
	case "basic":
		return AuthEnumBasic
	case "bearer":
		return AuthEnumBearer
	case "digest":
		return AuthEnumDigest
	case "hawk":
		return AuthEnumHawk
	case "noauth":
		return AuthEnumNoauth
	case "oauth1":
		return AuthEnumOauth1
	case "oauth2":
		return AuthEnumOauth2
	case "ntlm":
		return AuthEnumNtlm
	default:
		return AuthEnumUNDEFINED
	}
}

type BodyMode string

const (
	BodyModeRaw BodyMode  = "raw"
	BodyModeUrlencoded    = "urlencoded"
	BodyModeFormdata      = "formdata"
	BodyModeFile          = "file"
	BodyModeUNDEFINED     = "UNDEFINED"
)

func BodyModeFromString(value string) BodyMode {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "raw":
		return BodyModeRaw
	case "urlencoded":
		return BodyModeUrlencoded
	case "formdata":
		return BodyModeFormdata
	case "file":
		return BodyModeFile
	default:
		return BodyModeUNDEFINED
	}
}

type EventType string

const (
	EventTypeTest EventType  = "test"
	EventTypePrerequest      = "prerequest"
	EventTypeUNDEFINED       = "UNDEFINED"
)

func EventTypeFromString(value string) EventType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "test":
		return EventTypeTest
	case "prerequest":
		return EventTypePrerequest
	default:
		return EventTypeUNDEFINED
	}
}

type Method string

const (
	MethodGet Method  = "GET"
	MethodPut         = "PUT"
	MethodPost        = "POST"
	MethodPatch       = "PATCH"
	MethodDelete      = "DELETE"
	MethodCopy        = "COPY"
	MethodHead        = "HEAD"
	MethodOptions     = "OPTIONS"
	MethodLink        = "LINK"
	MethodUnlink      = "UNLINK"
	MethodPurge       = "PURGE"
	MethodLock        = "LOCK"
	MethodUnlock      = "UNLOCK"
	MethodPropfind    = "PROPFIND"
	MethodView        = "VIEW"
	MethodUNDEFINED   = "UNDEFINED"
)

func MethodFromString(value string) Method {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "get":
		return MethodGet
	case "put":
		return MethodPut
	case "post":
		return MethodPost
	case "patch":
		return MethodPatch
	case "delete":
		return MethodDelete
	case "copy":
		return MethodCopy
	case "head":
		return MethodHead
	case "options":
		return MethodOptions
	case "link":
		return MethodLink
	case "unlink":
		return MethodUnlink
	case "purge":
		return MethodPurge
	case "lock":
		return MethodLock
	case "unlock":
		return MethodUnlock
	case "propfind":
		return MethodPropfind
	case "view":
		return MethodView
	default:
		return MethodUNDEFINED
	}
}

type Auth struct {
	Type  AuthEnum    `json:"type"`
	Basic []BasicAuth `json:"basic,omitempty"`
}

func AuthFromMap(data interface{}) Auth {
	b, err := json.Marshal(data)
	if err == nil {
		return AuthFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func AuthFromJson(bytes io.Reader) Auth {
	var auth Auth
	json.NewDecoder(bytes).Decode(&auth)
	return auth
}

type BasicAuth struct {
	Key   string `json:"key"`
	Value string `json:"value"`
	Type  string `json:"type,omitempty"`
}

func BasicAuthFromMap(data interface{}) BasicAuth {
	b, err := json.Marshal(data)
	if err == nil {
		return BasicAuthFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func BasicAuthFromJson(bytes io.Reader) BasicAuth {
	var basicAuth BasicAuth
	json.NewDecoder(bytes).Decode(&basicAuth)
	return basicAuth
}

type Body struct {
	Raw        string          `json:"raw,omitempty"`
	Mode       BodyMode        `json:"mode,omitempty"`
	Urlencoded []UrlEncoded    `json:"urlencoded,omitempty"`
	File       File            `json:"file,omitempty"`
	Formdata   []FormParameter `json:"formdata,omitempty"`
}

func BodyFromMap(data interface{}) Body {
	b, err := json.Marshal(data)
	if err == nil {
		return BodyFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func BodyFromJson(bytes io.Reader) Body {
	var body Body
	json.NewDecoder(bytes).Decode(&body)
	return body
}

type Collection struct {
	Info     Info       `json:"info"`
	Item     []Items    `json:"item"`
	Event    []Event    `json:"event"`
	Variable []Variable `json:"variable"`
	Auth     Auth       `json:"auth,omitempty"`
}

func CollectionFromMap(data interface{}) Collection {
	b, err := json.Marshal(data)
	if err == nil {
		return CollectionFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func CollectionFromJson(bytes io.Reader) Collection {
	var collection Collection
	json.NewDecoder(bytes).Decode(&collection)
	return collection
}

type Description struct {
	Content string `json:"content,omitempty"`
	Type    string `json:"type,omitempty"`
}

func DescriptionFromMap(data interface{}) Description {
	b, err := json.Marshal(data)
	if err == nil {
		return DescriptionFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func DescriptionFromJson(bytes io.Reader) Description {
	var description Description
	json.NewDecoder(bytes).Decode(&description)
	return description
}

type Event struct {
	Listen   EventType `json:"listen"`
	Script   Script    `json:"script,omitempty"`
	Id       string    `json:"id,omitempty"`
	Disabled string    `json:"disabled,omitempty"`
}

func EventFromMap(data interface{}) Event {
	b, err := json.Marshal(data)
	if err == nil {
		return EventFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func EventFromJson(bytes io.Reader) Event {
	var event Event
	json.NewDecoder(bytes).Decode(&event)
	return event
}

type File struct {
	Src     string `json:"src,omitempty"`
	Content string `json:"content,omitempty"`
}

func FileFromMap(data interface{}) File {
	b, err := json.Marshal(data)
	if err == nil {
		return FileFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FileFromJson(bytes io.Reader) File {
	var file File
	json.NewDecoder(bytes).Decode(&file)
	return file
}

type Folder struct {
	Name        string      `json:"name"`
	Description Description `json:"description,omitempty"`
	Variable    []Variable  `json:"variable,omitempty"`
	Item        []Item      `json:"item"`
	Event       []Event     `json:"event,omitempty"`
	Auth        Auth        `json:"auth,omitempty"`
}

func FolderFromMap(data interface{}) Folder {
	b, err := json.Marshal(data)
	if err == nil {
		return FolderFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FolderFromJson(bytes io.Reader) Folder {
	var folder Folder
	json.NewDecoder(bytes).Decode(&folder)
	return folder
}

type FormParameter struct {
	Key         string      `json:"key"`
	Value       string      `json:"value,omitempty"`
	Disabled    string      `json:"disabled,omitempty"`
	Description Description `json:"description,omitempty"`
	ContentType string      `json:"contentType,omitempty"`
	Type        string      `json:"type,omitempty"`
}

func FormParameterFromMap(data interface{}) FormParameter {
	b, err := json.Marshal(data)
	if err == nil {
		return FormParameterFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FormParameterFromJson(bytes io.Reader) FormParameter {
	var formParameter FormParameter
	json.NewDecoder(bytes).Decode(&formParameter)
	return formParameter
}

type Header struct {
	Key         string      `json:"key"`
	Value       string      `json:"value"`
	Disabled    string      `json:"disabled,omitempty"`
	Description Description `json:"description,omitempty"`
}

func HeaderFromMap(data interface{}) Header {
	b, err := json.Marshal(data)
	if err == nil {
		return HeaderFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func HeaderFromJson(bytes io.Reader) Header {
	var header Header
	json.NewDecoder(bytes).Decode(&header)
	return header
}

type Info struct {
	Name        string      `json:"name"`
	PostmanId   string      `json:"postman_id,omitempty"`
	Description Description `json:"description,omitempty"`
	Version     string      `json:"version,omitempty"`
	Schema      string      `json:"schema"`
}

func InfoFromMap(data interface{}) Info {
	b, err := json.Marshal(data)
	if err == nil {
		return InfoFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func InfoFromJson(bytes io.Reader) Info {
	var info Info
	json.NewDecoder(bytes).Decode(&info)
	return info
}

type Item struct {
	Id          string      `json:"id,omitempty"`
	Name        string      `json:"name,omitempty"`
	Description Description `json:"description,omitempty"`
	Variable    []Variable  `json:"variable,omitempty"`
	Event       []Event     `json:"event,omitempty"`
	Request     Request     `json:"request"`
	Response    []Response  `json:"response,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 QueryParam struct {
	Key         string      `json:"key,omitempty"`
	Value       string      `json:"value,omitempty"`
	Disabled    string      `json:"disabled,omitempty"`
	Description Description `json:"description,omitempty"`
}

func QueryParamFromMap(data interface{}) QueryParam {
	b, err := json.Marshal(data)
	if err == nil {
		return QueryParamFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func QueryParamFromJson(bytes io.Reader) QueryParam {
	var queryParam QueryParam
	json.NewDecoder(bytes).Decode(&queryParam)
	return queryParam
}

type Request struct {
	Url         Url         `json:"url,omitempty"`
	Auth        Auth        `json:"auth,omitempty"`
	Method      Method      `json:"method,omitempty"`
	Description Description `json:"description,omitempty"`
	Header      []Header    `json:"header,omitempty"`
	Body        Body        `json:"body,omitempty"`
}

func RequestFromMap(data interface{}) Request {
	b, err := json.Marshal(data)
	if err == nil {
		return RequestFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func RequestFromJson(bytes io.Reader) Request {
	var request Request
	json.NewDecoder(bytes).Decode(&request)
	return request
}

type Response struct {
	Id              string   `json:"id,omitempty"`
	Name            string   `json:"name,omitempty"`
	OriginalRequest Request  `json:"originalRequest,omitempty"`
	ResponseTime    string   `json:"responseTime,omitempty"`
	Header          []Header `json:"header,omitempty"`
	Body            string   `json:"body,omitempty"`
	Status          string   `json:"status,omitempty"`
	Code            int32    `json:"code,omitempty"`
}

func ResponseFromMap(data interface{}) Response {
	b, err := json.Marshal(data)
	if err == nil {
		return ResponseFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ResponseFromJson(bytes io.Reader) Response {
	var response Response
	json.NewDecoder(bytes).Decode(&response)
	return response
}

type Script struct {
	Exec []string `json:"exec"`
	Type string   `json:"type"`
	Id   string   `json:"id,omitempty"`
	Src  string   `json:"src,omitempty"`
	Name string   `json:"name,omitempty"`
}

func ScriptFromMap(data interface{}) Script {
	b, err := json.Marshal(data)
	if err == nil {
		return ScriptFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ScriptFromJson(bytes io.Reader) Script {
	var script Script
	json.NewDecoder(bytes).Decode(&script)
	return script
}

type Url struct {
	Raw      string       `json:"raw,omitempty"`
	Protocol string       `json:"protocol,omitempty"`
	Host     []string     `json:"host,omitempty"`
	Path     []string     `json:"path,omitempty"`
	Port     string       `json:"port,omitempty"`
	Query    []QueryParam `json:"query,omitempty"`
	Hash     string       `json:"hash,omitempty"`
	Variable []Variable   `json:"variable,omitempty"`
}

func UrlFromMap(data interface{}) Url {
	b, err := json.Marshal(data)
	if err == nil {
		return UrlFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func UrlFromJson(bytes io.Reader) Url {
	var url Url
	json.NewDecoder(bytes).Decode(&url)
	return url
}

type UrlEncoded struct {
	Key         string      `json:"key"`
	Value       string      `json:"value,omitempty"`
	Disabled    string      `json:"disabled,omitempty"`
	Description Description `json:"description,omitempty"`
}

func UrlEncodedFromMap(data interface{}) UrlEncoded {
	b, err := json.Marshal(data)
	if err == nil {
		return UrlEncodedFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func UrlEncodedFromJson(bytes io.Reader) UrlEncoded {
	var urlEncoded UrlEncoded
	json.NewDecoder(bytes).Decode(&urlEncoded)
	return urlEncoded
}

/**
 * Using variables in your Postman requests eliminates the need to duplicate
 * requests, which can save a lot of time. Variables can be defined, and referenced
 * to from any part of a request.
 */
type Variable struct {
	Id          string      `json:"id,omitempty"`
	Key         string      `json:"key,omitempty"`
	Value       string      `json:"value,omitempty"`
	Type        string      `json:"type,omitempty"`
	Name        string      `json:"name,omitempty"`
	Description Description `json:"description,omitempty"`
	System      string      `json:"system,omitempty"`
	Disabled    string      `json:"disabled,omitempty"`
}

func VariableFromMap(data interface{}) Variable {
	b, err := json.Marshal(data)
	if err == nil {
		return VariableFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func VariableFromJson(bytes io.Reader) Variable {
	var variable Variable
	json.NewDecoder(bytes).Decode(&variable)
	return variable
}

type Items struct {
	Item      Item
	Folder    Folder
	Undefined string
}

func ItemsFromMap(data interface{}) Items {
	b, err := json.Marshal(data)
	if err == nil {
		return ItemsFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ItemsFromJson(bytes io.Reader) Items {
	var el map[string]interface{}
	json.NewDecoder(bytes).Decode(&el)
	switch el["type"] {
	case "item":
		return Items{Item: ItemFromMap(el)}
	case "folder":
		return Items{Folder: FolderFromMap(el)}
	default:
		return Items{Undefined: el["type"].(string)}
	}
}