package apibuilderapijson

/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.16.48
 * User agent: apibuilder app.apibuilder.io/apicollective/apibuilder-api-json/0.16.48/go_1_5_client
 */

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

const UserAgent = "apibuilder app.apibuilder.io/apicollective/apibuilder-api-json/0.16.48/go_1_5_client"
const Version = "0.16.48"
const VersionMajor = 0

type ParameterLocation string

const (
	ParameterLocationPath ParameterLocation  = "path"
	ParameterLocationQuery                   = "query"
	ParameterLocationForm                    = "form"
	ParameterLocationHeader                  = "header"
	ParameterLocationUNDEFINED               = "UNDEFINED"
)

func ParameterLocationFromString(value string) ParameterLocation {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "path":
		return ParameterLocationPath
	case "query":
		return ParameterLocationQuery
	case "form":
		return ParameterLocationForm
	case "header":
		return ParameterLocationHeader
	default:
		return ParameterLocationUNDEFINED
	}
}

type Annotation struct {
	Description string      `json:"description,omitempty"`
	Deprecation Deprecation `json:"deprecation,omitempty"`
}

func AnnotationFromMap(data interface{}) Annotation {
	b, err := json.Marshal(data)
	if err == nil {
		return AnnotationFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func AnnotationFromJson(bytes io.Reader) Annotation {
	var annotation Annotation
	json.NewDecoder(bytes).Decode(&annotation)
	return annotation
}

type ApiJson struct {
	Name        string                `json:"name"`
	Info        Info                  `json:"info,omitempty"`
	Namespace   string                `json:"namespace,omitempty"`
	BaseUrl     string                `json:"base_url,omitempty"`
	Description string                `json:"description,omitempty"`
	Imports     []Import              `json:"imports"`
	Headers     []Header              `json:"headers"`
	Enums       map[string]Enum       `json:"enums"`
	Interfaces  map[string]Interface  `json:"interfaces"`
	Templates   Templates             `json:"templates,omitempty"`
	Unions      map[string]Union      `json:"unions"`
	Models      map[string]Model      `json:"models"`
	Resources   map[string]Resource   `json:"resources"`
	Annotations map[string]Annotation `json:"annotations"`
	Attributes  []Attribute           `json:"attributes"`
}

func ApiJsonFromMap(data interface{}) ApiJson {
	b, err := json.Marshal(data)
	if err == nil {
		return ApiJsonFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ApiJsonFromJson(bytes io.Reader) ApiJson {
	var apiJson ApiJson
	json.NewDecoder(bytes).Decode(&apiJson)
	return apiJson
}

type Attribute struct {
	Name  string                 `json:"name"`
	Value map[string]interface{} `json:"value"`
}

func AttributeFromMap(data interface{}) Attribute {
	b, err := json.Marshal(data)
	if err == nil {
		return AttributeFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func AttributeFromJson(bytes io.Reader) Attribute {
	var attribute Attribute
	json.NewDecoder(bytes).Decode(&attribute)
	return attribute
}

type Body struct {
	Type        string      `json:"type"`
	Description string      `json:"description,omitempty"`
	Attributes  []Attribute `json:"attributes,omitempty"`
	Deprecation Deprecation `json:"deprecation,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 Contact struct {
	Name  string `json:"name,omitempty"`
	Url   string `json:"url,omitempty"`
	Email string `json:"email,omitempty"`
}

func ContactFromMap(data interface{}) Contact {
	b, err := json.Marshal(data)
	if err == nil {
		return ContactFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ContactFromJson(bytes io.Reader) Contact {
	var contact Contact
	json.NewDecoder(bytes).Decode(&contact)
	return contact
}

type Deprecation struct {
	Description string `json:"description,omitempty"`
}

func DeprecationFromMap(data interface{}) Deprecation {
	b, err := json.Marshal(data)
	if err == nil {
		return DeprecationFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func DeprecationFromJson(bytes io.Reader) Deprecation {
	var deprecation Deprecation
	json.NewDecoder(bytes).Decode(&deprecation)
	return deprecation
}

type Enum struct {
	Plural      string      `json:"plural,omitempty"`
	Description string      `json:"description,omitempty"`
	Values      []EnumValue `json:"values"`
	Attributes  []Attribute `json:"attributes,omitempty"`
	Deprecation Deprecation `json:"deprecation,omitempty"`
}

func EnumFromMap(data interface{}) Enum {
	b, err := json.Marshal(data)
	if err == nil {
		return EnumFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func EnumFromJson(bytes io.Reader) Enum {
	var enum Enum
	json.NewDecoder(bytes).Decode(&enum)
	return enum
}

type EnumValue struct {
	Name        string      `json:"name"`
	Value       string      `json:"value,omitempty"`
	Description string      `json:"description,omitempty"`
	Attributes  []Attribute `json:"attributes,omitempty"`
	Deprecation Deprecation `json:"deprecation,omitempty"`
}

func EnumValueFromMap(data interface{}) EnumValue {
	b, err := json.Marshal(data)
	if err == nil {
		return EnumValueFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func EnumValueFromJson(bytes io.Reader) EnumValue {
	var enumValue EnumValue
	json.NewDecoder(bytes).Decode(&enumValue)
	return enumValue
}

type Field struct {
	Name        string      `json:"name"`
	Type        string      `json:"type"`
	Description string      `json:"description,omitempty"`
	Required    string      `json:"required"`
	Default     interface{} `json:"default,omitempty"`
	Example     string      `json:"example,omitempty"`
	Minimum     int64       `json:"minimum,omitempty"`
	Maximum     int64       `json:"maximum,omitempty"`
	Attributes  []Attribute `json:"attributes,omitempty"`
	Annotations []string    `json:"annotations,omitempty"`
	Deprecation Deprecation `json:"deprecation,omitempty"`
}

func FieldFromMap(data interface{}) Field {
	b, err := json.Marshal(data)
	if err == nil {
		return FieldFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FieldFromJson(bytes io.Reader) Field {
	var field Field
	json.NewDecoder(bytes).Decode(&field)
	return field
}

type Header struct {
	Name        string      `json:"name"`
	Type        string      `json:"type"`
	Required    string      `json:"required"`
	Description string      `json:"description,omitempty"`
	Attributes  []Attribute `json:"attributes,omitempty"`
	Deprecation Deprecation `json:"deprecation,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 Import struct {
	Uri string `json:"uri"`
}

func ImportFromMap(data interface{}) Import {
	b, err := json.Marshal(data)
	if err == nil {
		return ImportFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ImportFromJson(bytes io.Reader) Import {
	var import_ Import
	json.NewDecoder(bytes).Decode(&import_)
	return import_
}

type Info struct {
	Contact Contact `json:"contact,omitempty"`
	License License `json:"license,omitempty"`
}

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 Interface struct {
	Plural      string      `json:"plural,omitempty"`
	Description string      `json:"description,omitempty"`
	Fields      []Field     `json:"fields,omitempty"`
	Attributes  []Attribute `json:"attributes,omitempty"`
	Deprecation Deprecation `json:"deprecation,omitempty"`
}

func InterfaceFromMap(data interface{}) Interface {
	b, err := json.Marshal(data)
	if err == nil {
		return InterfaceFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func InterfaceFromJson(bytes io.Reader) Interface {
	var interface_ Interface
	json.NewDecoder(bytes).Decode(&interface_)
	return interface_
}

/**
 * Describes the software license contact for this service
 */
type License struct {
	Name string `json:"name"`
	Url  string `json:"url,omitempty"`
}

func LicenseFromMap(data interface{}) License {
	b, err := json.Marshal(data)
	if err == nil {
		return LicenseFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func LicenseFromJson(bytes io.Reader) License {
	var license License
	json.NewDecoder(bytes).Decode(&license)
	return license
}

type Model struct {
	Description string                `json:"description,omitempty"`
	Plural      string                `json:"plural,omitempty"`
	Fields      []Field               `json:"fields"`
	Attributes  []Attribute           `json:"attributes,omitempty"`
	Interfaces  []string              `json:"interfaces,omitempty"`
	Templates   []TemplateDeclaration `json:"templates,omitempty"`
	Deprecation Deprecation           `json:"deprecation,omitempty"`
}

func ModelFromMap(data interface{}) Model {
	b, err := json.Marshal(data)
	if err == nil {
		return ModelFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ModelFromJson(bytes io.Reader) Model {
	var model Model
	json.NewDecoder(bytes).Decode(&model)
	return model
}

type Operation struct {
	Method      string              `json:"method"`
	Path        string              `json:"path,omitempty"`
	Description string              `json:"description,omitempty"`
	Body        Body                `json:"body,omitempty"`
	Parameters  []Parameter         `json:"parameters,omitempty"`
	Responses   map[string]Response `json:"responses,omitempty"`
	Attributes  []Attribute         `json:"attributes,omitempty"`
	Deprecation Deprecation         `json:"deprecation,omitempty"`
}

func OperationFromMap(data interface{}) Operation {
	b, err := json.Marshal(data)
	if err == nil {
		return OperationFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func OperationFromJson(bytes io.Reader) Operation {
	var operation Operation
	json.NewDecoder(bytes).Decode(&operation)
	return operation
}

type Parameter struct {
	Name        string            `json:"name"`
	Type        string            `json:"type"`
	Location    ParameterLocation `json:"location"`
	Description string            `json:"description,omitempty"`
	Required    string            `json:"required"`
	Default     interface{}       `json:"default,omitempty"`
	Minimum     int64             `json:"minimum,omitempty"`
	Maximum     int64             `json:"maximum,omitempty"`
	Example     string            `json:"example,omitempty"`
	Attributes  []Attribute       `json:"attributes,omitempty"`
	Deprecation Deprecation       `json:"deprecation,omitempty"`
}

func ParameterFromMap(data interface{}) Parameter {
	b, err := json.Marshal(data)
	if err == nil {
		return ParameterFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ParameterFromJson(bytes io.Reader) Parameter {
	var parameter Parameter
	json.NewDecoder(bytes).Decode(&parameter)
	return parameter
}

type Resource struct {
	Path        string                `json:"path,omitempty"`
	Description string                `json:"description,omitempty"`
	Operations  []Operation           `json:"operations"`
	Attributes  []Attribute           `json:"attributes,omitempty"`
	Templates   []TemplateDeclaration `json:"templates,omitempty"`
	Deprecation Deprecation           `json:"deprecation,omitempty"`
}

func ResourceFromMap(data interface{}) Resource {
	b, err := json.Marshal(data)
	if err == nil {
		return ResourceFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ResourceFromJson(bytes io.Reader) Resource {
	var resource Resource
	json.NewDecoder(bytes).Decode(&resource)
	return resource
}

type Response struct {
	Type        string      `json:"type"`
	Headers     []Header    `json:"headers,omitempty"`
	Description string      `json:"description,omitempty"`
	Deprecation Deprecation `json:"deprecation,omitempty"`
	Attributes  []Attribute `json:"attributes,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 TemplateDeclaration struct {
	Name string            `json:"name"`
	Cast map[string]string `json:"cast,omitempty"`
}

func TemplateDeclarationFromMap(data interface{}) TemplateDeclaration {
	b, err := json.Marshal(data)
	if err == nil {
		return TemplateDeclarationFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TemplateDeclarationFromJson(bytes io.Reader) TemplateDeclaration {
	var templateDeclaration TemplateDeclaration
	json.NewDecoder(bytes).Decode(&templateDeclaration)
	return templateDeclaration
}

/**
 * Experimental
 */
type Templates struct {
	Models    map[string]Model    `json:"models,omitempty"`
	Resources map[string]Resource `json:"resources,omitempty"`
}

func TemplatesFromMap(data interface{}) Templates {
	b, err := json.Marshal(data)
	if err == nil {
		return TemplatesFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TemplatesFromJson(bytes io.Reader) Templates {
	var templates Templates
	json.NewDecoder(bytes).Decode(&templates)
	return templates
}

type Union struct {
	Plural        string      `json:"plural,omitempty"`
	Discriminator string      `json:"discriminator,omitempty"`
	Description   string      `json:"description,omitempty"`
	Types         []UnionType `json:"types"`
	Attributes    []Attribute `json:"attributes,omitempty"`
	Interfaces    []string    `json:"interfaces,omitempty"`
	Deprecation   Deprecation `json:"deprecation,omitempty"`
}

func UnionFromMap(data interface{}) Union {
	b, err := json.Marshal(data)
	if err == nil {
		return UnionFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func UnionFromJson(bytes io.Reader) Union {
	var union Union
	json.NewDecoder(bytes).Decode(&union)
	return union
}

type UnionType struct {
	Type               string      `json:"type"`
	Description        string      `json:"description,omitempty"`
	Default            string      `json:"default"`
	DiscriminatorValue string      `json:"discriminator_value,omitempty"`
	Attributes         []Attribute `json:"attributes,omitempty"`
	Deprecation        Deprecation `json:"deprecation,omitempty"`
}

func UnionTypeFromMap(data interface{}) UnionType {
	b, err := json.Marshal(data)
	if err == nil {
		return UnionTypeFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func UnionTypeFromJson(bytes io.Reader) UnionType {
	var unionType UnionType
	json.NewDecoder(bytes).Decode(&unionType)
	return unionType
}