package flowerate

/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.0.1-dev
 * User agent: apibuilder app.apibuilder.io/chenggit/flowerate/0.0.1-dev/go_1_5_client
 */

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

const UserAgent = "apibuilder app.apibuilder.io/chenggit/flowerate/0.0.1-dev/go_1_5_client"
const Version = "0.0.1-dev"
const VersionMajor = 0

type Currency string

const (
	CurrencyAed Currency  = "AED"
	CurrencyAfn           = "AFN"
	CurrencyAll           = "ALL"
	CurrencyAmd           = "AMD"
	CurrencyAng           = "ANG"
	CurrencyAoa           = "AOA"
	CurrencyArs           = "ARS"
	CurrencyAud           = "AUD"
	CurrencyAwg           = "AWG"
	CurrencyAzn           = "AZN"
	CurrencyBam           = "BAM"
	CurrencyBbd           = "BBD"
	CurrencyBdt           = "BDT"
	CurrencyBgn           = "BGN"
	CurrencyBhd           = "BHD"
	CurrencyBif           = "BIF"
	CurrencyBmd           = "BMD"
	CurrencyBnd           = "BND"
	CurrencyBob           = "BOB"
	CurrencyBrl           = "BRL"
	CurrencyBsd           = "BSD"
	CurrencyBtc           = "BTC"
	CurrencyBtn           = "BTN"
	CurrencyBwp           = "BWP"
	CurrencyByn           = "BYN"
	CurrencyByr           = "BYR"
	CurrencyBzd           = "BZD"
	CurrencyCad           = "CAD"
	CurrencyCdf           = "CDF"
	CurrencyChf           = "CHF"
	CurrencyClf           = "CLF"
	CurrencyClp           = "CLP"
	CurrencyCny           = "CNY"
	CurrencyCop           = "COP"
	CurrencyCrc           = "CRC"
	CurrencyCuc           = "CUC"
	CurrencyCup           = "CUP"
	CurrencyCve           = "CVE"
	CurrencyCzk           = "CZK"
	CurrencyDjf           = "DJF"
	CurrencyDkk           = "DKK"
	CurrencyDop           = "DOP"
	CurrencyDzd           = "DZD"
	CurrencyEgp           = "EGP"
	CurrencyErn           = "ERN"
	CurrencyEtb           = "ETB"
	CurrencyEur           = "EUR"
	CurrencyFjd           = "FJD"
	CurrencyFkp           = "FKP"
	CurrencyGbp           = "GBP"
	CurrencyGel           = "GEL"
	CurrencyGgp           = "GGP"
	CurrencyGhs           = "GHS"
	CurrencyGip           = "GIP"
	CurrencyGmd           = "GMD"
	CurrencyGnf           = "GNF"
	CurrencyGtq           = "GTQ"
	CurrencyGyd           = "GYD"
	CurrencyHkd           = "HKD"
	CurrencyHnl           = "HNL"
	CurrencyHrk           = "HRK"
	CurrencyHtg           = "HTG"
	CurrencyHuf           = "HUF"
	CurrencyIdr           = "IDR"
	CurrencyIls           = "ILS"
	CurrencyImp           = "IMP"
	CurrencyInr           = "INR"
	CurrencyIqd           = "IQD"
	CurrencyIrr           = "IRR"
	CurrencyIsk           = "ISK"
	CurrencyJep           = "JEP"
	CurrencyJmd           = "JMD"
	CurrencyJod           = "JOD"
	CurrencyJpy           = "JPY"
	CurrencyKes           = "KES"
	CurrencyKgs           = "KGS"
	CurrencyKhr           = "KHR"
	CurrencyKmf           = "KMF"
	CurrencyKpw           = "KPW"
	CurrencyKrw           = "KRW"
	CurrencyKwd           = "KWD"
	CurrencyKyd           = "KYD"
	CurrencyKzt           = "KZT"
	CurrencyLak           = "LAK"
	CurrencyLbp           = "LBP"
	CurrencyLkr           = "LKR"
	CurrencyLrd           = "LRD"
	CurrencyLsl           = "LSL"
	CurrencyLtl           = "LTL"
	CurrencyLvl           = "LVL"
	CurrencyLyd           = "LYD"
	CurrencyMad           = "MAD"
	CurrencyMdl           = "MDL"
	CurrencyMga           = "MGA"
	CurrencyMkd           = "MKD"
	CurrencyMmk           = "MMK"
	CurrencyMnt           = "MNT"
	CurrencyMop           = "MOP"
	CurrencyMro           = "MRO"
	CurrencyMur           = "MUR"
	CurrencyMvr           = "MVR"
	CurrencyMwk           = "MWK"
	CurrencyMxn           = "MXN"
	CurrencyMyr           = "MYR"
	CurrencyMzn           = "MZN"
	CurrencyNad           = "NAD"
	CurrencyNgn           = "NGN"
	CurrencyNio           = "NIO"
	CurrencyNok           = "NOK"
	CurrencyNpr           = "NPR"
	CurrencyNzd           = "NZD"
	CurrencyOmr           = "OMR"
	CurrencyPab           = "PAB"
	CurrencyPen           = "PEN"
	CurrencyPgk           = "PGK"
	CurrencyPhp           = "PHP"
	CurrencyPkr           = "PKR"
	CurrencyPln           = "PLN"
	CurrencyPyg           = "PYG"
	CurrencyQar           = "QAR"
	CurrencyRon           = "RON"
	CurrencyRsd           = "RSD"
	CurrencyRub           = "RUB"
	CurrencyRwf           = "RWF"
	CurrencySar           = "SAR"
	CurrencySbd           = "SBD"
	CurrencyScr           = "SCR"
	CurrencySdg           = "SDG"
	CurrencySek           = "SEK"
	CurrencySgd           = "SGD"
	CurrencyShp           = "SHP"
	CurrencySll           = "SLL"
	CurrencySos           = "SOS"
	CurrencySrd           = "SRD"
	CurrencyStd           = "STD"
	CurrencySvc           = "SVC"
	CurrencySyp           = "SYP"
	CurrencySzl           = "SZL"
	CurrencyThb           = "THB"
	CurrencyTjs           = "TJS"
	CurrencyTmt           = "TMT"
	CurrencyTnd           = "TND"
	CurrencyTop           = "TOP"
	CurrencyTry           = "TRY"
	CurrencyTtd           = "TTD"
	CurrencyTwd           = "TWD"
	CurrencyTzs           = "TZS"
	CurrencyUah           = "UAH"
	CurrencyUgx           = "UGX"
	CurrencyUsd           = "USD"
	CurrencyUyu           = "UYU"
	CurrencyUzs           = "UZS"
	CurrencyVef           = "VEF"
	CurrencyVnd           = "VND"
	CurrencyVuv           = "VUV"
	CurrencyWst           = "WST"
	CurrencyXaf           = "XAF"
	CurrencyXag           = "XAG"
	CurrencyXau           = "XAU"
	CurrencyXcd           = "XCD"
	CurrencyXdr           = "XDR"
	CurrencyXof           = "XOF"
	CurrencyXpf           = "XPF"
	CurrencyYer           = "YER"
	CurrencyZar           = "ZAR"
	CurrencyZmk           = "ZMK"
	CurrencyZmw           = "ZMW"
	CurrencyZwl           = "ZWL"
	CurrencyUNDEFINED     = "UNDEFINED"
)

func CurrencyFromString(value string) Currency {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "aed":
		return CurrencyAed
	case "afn":
		return CurrencyAfn
	case "all":
		return CurrencyAll
	case "amd":
		return CurrencyAmd
	case "ang":
		return CurrencyAng
	case "aoa":
		return CurrencyAoa
	case "ars":
		return CurrencyArs
	case "aud":
		return CurrencyAud
	case "awg":
		return CurrencyAwg
	case "azn":
		return CurrencyAzn
	case "bam":
		return CurrencyBam
	case "bbd":
		return CurrencyBbd
	case "bdt":
		return CurrencyBdt
	case "bgn":
		return CurrencyBgn
	case "bhd":
		return CurrencyBhd
	case "bif":
		return CurrencyBif
	case "bmd":
		return CurrencyBmd
	case "bnd":
		return CurrencyBnd
	case "bob":
		return CurrencyBob
	case "brl":
		return CurrencyBrl
	case "bsd":
		return CurrencyBsd
	case "btc":
		return CurrencyBtc
	case "btn":
		return CurrencyBtn
	case "bwp":
		return CurrencyBwp
	case "byn":
		return CurrencyByn
	case "byr":
		return CurrencyByr
	case "bzd":
		return CurrencyBzd
	case "cad":
		return CurrencyCad
	case "cdf":
		return CurrencyCdf
	case "chf":
		return CurrencyChf
	case "clf":
		return CurrencyClf
	case "clp":
		return CurrencyClp
	case "cny":
		return CurrencyCny
	case "cop":
		return CurrencyCop
	case "crc":
		return CurrencyCrc
	case "cuc":
		return CurrencyCuc
	case "cup":
		return CurrencyCup
	case "cve":
		return CurrencyCve
	case "czk":
		return CurrencyCzk
	case "djf":
		return CurrencyDjf
	case "dkk":
		return CurrencyDkk
	case "dop":
		return CurrencyDop
	case "dzd":
		return CurrencyDzd
	case "egp":
		return CurrencyEgp
	case "ern":
		return CurrencyErn
	case "etb":
		return CurrencyEtb
	case "eur":
		return CurrencyEur
	case "fjd":
		return CurrencyFjd
	case "fkp":
		return CurrencyFkp
	case "gbp":
		return CurrencyGbp
	case "gel":
		return CurrencyGel
	case "ggp":
		return CurrencyGgp
	case "ghs":
		return CurrencyGhs
	case "gip":
		return CurrencyGip
	case "gmd":
		return CurrencyGmd
	case "gnf":
		return CurrencyGnf
	case "gtq":
		return CurrencyGtq
	case "gyd":
		return CurrencyGyd
	case "hkd":
		return CurrencyHkd
	case "hnl":
		return CurrencyHnl
	case "hrk":
		return CurrencyHrk
	case "htg":
		return CurrencyHtg
	case "huf":
		return CurrencyHuf
	case "idr":
		return CurrencyIdr
	case "ils":
		return CurrencyIls
	case "imp":
		return CurrencyImp
	case "inr":
		return CurrencyInr
	case "iqd":
		return CurrencyIqd
	case "irr":
		return CurrencyIrr
	case "isk":
		return CurrencyIsk
	case "jep":
		return CurrencyJep
	case "jmd":
		return CurrencyJmd
	case "jod":
		return CurrencyJod
	case "jpy":
		return CurrencyJpy
	case "kes":
		return CurrencyKes
	case "kgs":
		return CurrencyKgs
	case "khr":
		return CurrencyKhr
	case "kmf":
		return CurrencyKmf
	case "kpw":
		return CurrencyKpw
	case "krw":
		return CurrencyKrw
	case "kwd":
		return CurrencyKwd
	case "kyd":
		return CurrencyKyd
	case "kzt":
		return CurrencyKzt
	case "lak":
		return CurrencyLak
	case "lbp":
		return CurrencyLbp
	case "lkr":
		return CurrencyLkr
	case "lrd":
		return CurrencyLrd
	case "lsl":
		return CurrencyLsl
	case "ltl":
		return CurrencyLtl
	case "lvl":
		return CurrencyLvl
	case "lyd":
		return CurrencyLyd
	case "mad":
		return CurrencyMad
	case "mdl":
		return CurrencyMdl
	case "mga":
		return CurrencyMga
	case "mkd":
		return CurrencyMkd
	case "mmk":
		return CurrencyMmk
	case "mnt":
		return CurrencyMnt
	case "mop":
		return CurrencyMop
	case "mro":
		return CurrencyMro
	case "mur":
		return CurrencyMur
	case "mvr":
		return CurrencyMvr
	case "mwk":
		return CurrencyMwk
	case "mxn":
		return CurrencyMxn
	case "myr":
		return CurrencyMyr
	case "mzn":
		return CurrencyMzn
	case "nad":
		return CurrencyNad
	case "ngn":
		return CurrencyNgn
	case "nio":
		return CurrencyNio
	case "nok":
		return CurrencyNok
	case "npr":
		return CurrencyNpr
	case "nzd":
		return CurrencyNzd
	case "omr":
		return CurrencyOmr
	case "pab":
		return CurrencyPab
	case "pen":
		return CurrencyPen
	case "pgk":
		return CurrencyPgk
	case "php":
		return CurrencyPhp
	case "pkr":
		return CurrencyPkr
	case "pln":
		return CurrencyPln
	case "pyg":
		return CurrencyPyg
	case "qar":
		return CurrencyQar
	case "ron":
		return CurrencyRon
	case "rsd":
		return CurrencyRsd
	case "rub":
		return CurrencyRub
	case "rwf":
		return CurrencyRwf
	case "sar":
		return CurrencySar
	case "sbd":
		return CurrencySbd
	case "scr":
		return CurrencyScr
	case "sdg":
		return CurrencySdg
	case "sek":
		return CurrencySek
	case "sgd":
		return CurrencySgd
	case "shp":
		return CurrencyShp
	case "sll":
		return CurrencySll
	case "sos":
		return CurrencySos
	case "srd":
		return CurrencySrd
	case "std":
		return CurrencyStd
	case "svc":
		return CurrencySvc
	case "syp":
		return CurrencySyp
	case "szl":
		return CurrencySzl
	case "thb":
		return CurrencyThb
	case "tjs":
		return CurrencyTjs
	case "tmt":
		return CurrencyTmt
	case "tnd":
		return CurrencyTnd
	case "top":
		return CurrencyTop
	case "try":
		return CurrencyTry
	case "ttd":
		return CurrencyTtd
	case "twd":
		return CurrencyTwd
	case "tzs":
		return CurrencyTzs
	case "uah":
		return CurrencyUah
	case "ugx":
		return CurrencyUgx
	case "usd":
		return CurrencyUsd
	case "uyu":
		return CurrencyUyu
	case "uzs":
		return CurrencyUzs
	case "vef":
		return CurrencyVef
	case "vnd":
		return CurrencyVnd
	case "vuv":
		return CurrencyVuv
	case "wst":
		return CurrencyWst
	case "xaf":
		return CurrencyXaf
	case "xag":
		return CurrencyXag
	case "xau":
		return CurrencyXau
	case "xcd":
		return CurrencyXcd
	case "xdr":
		return CurrencyXdr
	case "xof":
		return CurrencyXof
	case "xpf":
		return CurrencyXpf
	case "yer":
		return CurrencyYer
	case "zar":
		return CurrencyZar
	case "zmk":
		return CurrencyZmk
	case "zmw":
		return CurrencyZmw
	case "zwl":
		return CurrencyZwl
	default:
		return CurrencyUNDEFINED
	}
}

type CurrencyRateEvent string

const (
	CurrencyRateEventCurrencyRateChange CurrencyRateEvent  = "CurrencyRateChange"
	CurrencyRateEventUNDEFINED                             = "UNDEFINED"
)

func CurrencyRateEventFromString(value string) CurrencyRateEvent {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "currencyratechange":
		return CurrencyRateEventCurrencyRateChange
	default:
		return CurrencyRateEventUNDEFINED
	}
}

/**
 * fixer.io error detail inside a failure response
 */
type FixerErrorDetail struct {
	Code int64  `json:"code"`
	Type string `json:"type"`
}

func FixerErrorDetailFromMap(data interface{}) FixerErrorDetail {
	b, err := json.Marshal(data)
	if err == nil {
		return FixerErrorDetailFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FixerErrorDetailFromJson(bytes io.Reader) FixerErrorDetail {
	var fixerErrorDetail FixerErrorDetail
	json.NewDecoder(bytes).Decode(&fixerErrorDetail)
	return fixerErrorDetail
}

/**
 * fixer.io failure response for exchange rate between two currencies
 */
type FixerRatesFailureResponse struct {
	Success string           `json:"success"`
	Error   FixerErrorDetail `json:"error"`
}

func FixerRatesFailureResponseFromMap(data interface{}) FixerRatesFailureResponse {
	b, err := json.Marshal(data)
	if err == nil {
		return FixerRatesFailureResponseFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FixerRatesFailureResponseFromJson(bytes io.Reader) FixerRatesFailureResponse {
	var fixerRatesFailureResponse FixerRatesFailureResponse
	json.NewDecoder(bytes).Decode(&fixerRatesFailureResponse)
	return fixerRatesFailureResponse
}

/**
 * fixer.io response for exchange rate between two currencies
 */
type FixerRatesSuccessResponse struct {
	Success   string             `json:"success"`
	Base      Currency           `json:"base"`
	Rates     map[string]float64 `json:"rates"`
	Timestamp int64              `json:"timestamp"`
}

func FixerRatesSuccessResponseFromMap(data interface{}) FixerRatesSuccessResponse {
	b, err := json.Marshal(data)
	if err == nil {
		return FixerRatesSuccessResponseFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FixerRatesSuccessResponseFromJson(bytes io.Reader) FixerRatesSuccessResponse {
	var fixerRatesSuccessResponse FixerRatesSuccessResponse
	json.NewDecoder(bytes).Decode(&fixerRatesSuccessResponse)
	return fixerRatesSuccessResponse
}

/**
 * flowerate response for exchange rate between two currencies
 */
type RateBetweenResponse struct {
	Base      Currency `json:"base"`
	Target    Currency `json:"target"`
	Rate      float64  `json:"rate"`
	Timestamp int64    `json:"timestamp"`
}

func RateBetweenResponseFromMap(data interface{}) RateBetweenResponse {
	b, err := json.Marshal(data)
	if err == nil {
		return RateBetweenResponseFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func RateBetweenResponseFromJson(bytes io.Reader) RateBetweenResponse {
	var rateBetweenResponse RateBetweenResponse
	json.NewDecoder(bytes).Decode(&rateBetweenResponse)
	return rateBetweenResponse
}

/**
 * flowerate response for exchange rate for base currency to all currencies
 */
type RateToAllResponse struct {
	Base      Currency           `json:"base"`
	Rates     map[string]float64 `json:"rates"`
	Timestamp int64              `json:"timestamp"`
}

func RateToAllResponseFromMap(data interface{}) RateToAllResponse {
	b, err := json.Marshal(data)
	if err == nil {
		return RateToAllResponseFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func RateToAllResponseFromJson(bytes io.Reader) RateToAllResponse {
	var rateToAllResponse RateToAllResponse
	json.NewDecoder(bytes).Decode(&rateToAllResponse)
	return rateToAllResponse
}

/**
 * describe subscribed action and corresponding url of a webhook
 */
type WebhookDetail struct {
	CurrencyRateEvent CurrencyRateEvent `json:"currencyRateEvent"`
	Url               string            `json:"url"`
}

func WebhookDetailFromMap(data interface{}) WebhookDetail {
	b, err := json.Marshal(data)
	if err == nil {
		return WebhookDetailFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func WebhookDetailFromJson(bytes io.Reader) WebhookDetail {
	var webhookDetail WebhookDetail
	json.NewDecoder(bytes).Decode(&webhookDetail)
	return webhookDetail
}

/**
 * payload of POST request to register a webhook
 */
type WebhookRegisterRequest struct {
	ClientId string          `json:"clientId"`
	Webhooks []WebhookDetail `json:"webhooks"`
}

func WebhookRegisterRequestFromMap(data interface{}) WebhookRegisterRequest {
	b, err := json.Marshal(data)
	if err == nil {
		return WebhookRegisterRequestFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func WebhookRegisterRequestFromJson(bytes io.Reader) WebhookRegisterRequest {
	var webhookRegisterRequest WebhookRegisterRequest
	json.NewDecoder(bytes).Decode(&webhookRegisterRequest)
	return webhookRegisterRequest
}

/**
 * Models rates response from fixer io
 */
type FixerRateResponse struct {
	FixerRatesSuccessResponse FixerRatesSuccessResponse
	FixerRatesFailureResponse FixerRatesFailureResponse
	Undefined                 string
}

func FixerRateResponseFromMap(data interface{}) FixerRateResponse {
	b, err := json.Marshal(data)
	if err == nil {
		return FixerRateResponseFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FixerRateResponseFromJson(bytes io.Reader) FixerRateResponse {
// TODO: Not yet supported
}