package apibuilderswagger

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

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

const UserAgent = "apibuilder app.apibuilder.io/apicollective/apibuilder-swagger/0.16.74/go_1_5_client"
const Version = "0.16.74"
const VersionMajor = 0

type ApiKeyInType string

const (
	ApiKeyInTypeQuery ApiKeyInType  = "query"
	ApiKeyInTypeHeader              = "header"
	ApiKeyInTypeUNDEFINED           = "UNDEFINED"
)

func ApiKeyInTypeFromString(value string) ApiKeyInType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "query":
		return ApiKeyInTypeQuery
	case "header":
		return ApiKeyInTypeHeader
	default:
		return ApiKeyInTypeUNDEFINED
	}
}

type CollectionFormatType string

const (
	CollectionFormatTypeCsv CollectionFormatType  = "csv"
	CollectionFormatTypeSsv                       = "ssv"
	CollectionFormatTypeTsv                       = "tsv"
	CollectionFormatTypePipes                     = "pipes"
	CollectionFormatTypeUNDEFINED                 = "UNDEFINED"
)

func CollectionFormatTypeFromString(value string) CollectionFormatType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "csv":
		return CollectionFormatTypeCsv
	case "ssv":
		return CollectionFormatTypeSsv
	case "tsv":
		return CollectionFormatTypeTsv
	case "pipes":
		return CollectionFormatTypePipes
	default:
		return CollectionFormatTypeUNDEFINED
	}
}

type FormatType string

const (
	FormatTypeBinary FormatType  = "binary"
	FormatTypeByte               = "byte"
	FormatTypeDate               = "date"
	FormatTypeDateTime           = "date-time"
	FormatTypeDouble             = "double"
	FormatTypeFloat              = "float"
	FormatTypeInt32              = "int32"
	FormatTypeInt64              = "int64"
	FormatTypePassword           = "password"
	FormatTypeUNDEFINED          = "UNDEFINED"
)

func FormatTypeFromString(value string) FormatType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "binary":
		return FormatTypeBinary
	case "byte":
		return FormatTypeByte
	case "date":
		return FormatTypeDate
	case "date-time":
		return FormatTypeDateTime
	case "double":
		return FormatTypeDouble
	case "float":
		return FormatTypeFloat
	case "int32":
		return FormatTypeInt32
	case "int64":
		return FormatTypeInt64
	case "password":
		return FormatTypePassword
	default:
		return FormatTypeUNDEFINED
	}
}

type ItemsType string

const (
	ItemsTypeString ItemsType  = "string"
	ItemsTypeNumber            = "number"
	ItemsTypeInteger           = "integer"
	ItemsTypeBoolean           = "boolean"
	ItemsTypeArray             = "array"
	ItemsTypeUNDEFINED         = "UNDEFINED"
)

func ItemsTypeFromString(value string) ItemsType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "string":
		return ItemsTypeString
	case "number":
		return ItemsTypeNumber
	case "integer":
		return ItemsTypeInteger
	case "boolean":
		return ItemsTypeBoolean
	case "array":
		return ItemsTypeArray
	default:
		return ItemsTypeUNDEFINED
	}
}

type ParameterInType string

const (
	ParameterInTypeQuery ParameterInType  = "query"
	ParameterInTypeHeader                 = "header"
	ParameterInTypePath                   = "path"
	ParameterInTypeFormData               = "formData"
	ParameterInTypeBody                   = "body"
	ParameterInTypeUNDEFINED              = "UNDEFINED"
)

func ParameterInTypeFromString(value string) ParameterInType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "query":
		return ParameterInTypeQuery
	case "header":
		return ParameterInTypeHeader
	case "path":
		return ParameterInTypePath
	case "formdata":
		return ParameterInTypeFormData
	case "body":
		return ParameterInTypeBody
	default:
		return ParameterInTypeUNDEFINED
	}
}

type SecuritySchemeType string

const (
	SecuritySchemeTypeBasic SecuritySchemeType  = "basic"
	SecuritySchemeTypeApiKey                    = "apiKey"
	SecuritySchemeTypeOauth2                    = "oauth2"
	SecuritySchemeTypeUNDEFINED                 = "UNDEFINED"
)

func SecuritySchemeTypeFromString(value string) SecuritySchemeType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "basic":
		return SecuritySchemeTypeBasic
	case "apikey":
		return SecuritySchemeTypeApiKey
	case "oauth2":
		return SecuritySchemeTypeOauth2
	default:
		return SecuritySchemeTypeUNDEFINED
	}
}

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 ExternalDocumentation struct {
	Description string `json:"description,omitempty"`
	Url         string `json:"url"`
}

func ExternalDocumentationFromMap(data interface{}) ExternalDocumentation {
	b, err := json.Marshal(data)
	if err == nil {
		return ExternalDocumentationFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ExternalDocumentationFromJson(bytes io.Reader) ExternalDocumentation {
	var externalDocumentation ExternalDocumentation
	json.NewDecoder(bytes).Decode(&externalDocumentation)
	return externalDocumentation
}

/**
 * TODO: Can this be a union type with items?
 */
type Header struct {
	Description      string                   `json:"description,omitempty"`
	Type             ItemsType                `json:"type"`
	Format           FormatType               `json:"format,omitempty"`
	Items            Items                    `json:"items,omitempty"`
	CollectionFormat CollectionFormatType     `json:"collectionFormat,omitempty"`
	Default          map[string]interface{}   `json:"default,omitempty"`
	Maximum          int64                    `json:"maximum,omitempty"`
	ExclusiveMaximum string                   `json:"exclusiveMaximum,omitempty"`
	Minimum          int64                    `json:"minimum,omitempty"`
	ExclusiveMinimum string                   `json:"exclusiveMinimum,omitempty"`
	MaxLength        int32                    `json:"maxLength,omitempty"`
	MinLength        int32                    `json:"minLength,omitempty"`
	Pattern          string                   `json:"pattern,omitempty"`
	MaxItems         int32                    `json:"maxItems,omitempty"`
	MinItems         int32                    `json:"minItems,omitempty"`
	UniqueItems      string                   `json:"uniqueItems,omitempty"`
	Enum             []map[string]interface{} `json:"enum,omitempty"`
	MultipleOf       int64                    `json:"multipleOf,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 {
	Title          string  `json:"title"`
	Description    string  `json:"description,omitempty"`
	TermsOfService string  `json:"termsOfService,omitempty"`
	Contact        Contact `json:"contact,omitempty"`
	License        License `json:"license,omitempty"`
	Version        string  `json:"version"`
}

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 Items struct {
	Type             ItemsType                `json:"type"`
	Format           FormatType               `json:"format,omitempty"`
	Items            Items                    `json:"items,omitempty"`
	CollectionFormat CollectionFormatType     `json:"collectionFormat,omitempty"`
	Default          map[string]interface{}   `json:"default,omitempty"`
	Maximum          int64                    `json:"maximum,omitempty"`
	ExclusiveMaximum string                   `json:"exclusiveMaximum,omitempty"`
	Minimum          int64                    `json:"minimum,omitempty"`
	ExclusiveMinimum string                   `json:"exclusiveMinimum,omitempty"`
	MaxLength        int32                    `json:"maxLength,omitempty"`
	MinLength        int32                    `json:"minLength,omitempty"`
	Pattern          string                   `json:"pattern,omitempty"`
	MaxItems         int32                    `json:"maxItems,omitempty"`
	MinItems         int32                    `json:"minItems,omitempty"`
	UniqueItems      string                   `json:"uniqueItems,omitempty"`
	Enum             []map[string]interface{} `json:"enum,omitempty"`
	MultipleOf       int64                    `json:"multipleOf,omitempty"`
}

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 items Items
	json.NewDecoder(bytes).Decode(&items)
	return items
}

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 Operation struct {
	Tags         []string                 `json:"tags,omitempty"`
	Summary      string                   `json:"summary,omitempty"`
	Description  string                   `json:"description,omitempty"`
	ExternalDocs ExternalDocumentation    `json:"externalDocs,omitempty"`
	OperationId  string                   `json:"operationId,omitempty"`
	Consumes     []string                 `json:"consumes,omitempty"`
	Produces     []string                 `json:"produces,omitempty"`
	Parameters   []ParameterOrRef         `json:"parameters,omitempty"`
	Responses    map[string]ResponseOrRef `json:"responses"`
	Schemes      []string                 `json:"schemes,omitempty"`
	Deprecated   string                   `json:"deprecated,omitempty"`
	Security     []map[string][]string    `json:"security,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
}

/**
 * TODO: This might need to be a complex union type, given the different
 * requirements based on the 'in' property.
 * http://swagger.io/specification/#parameterObject
 */
type Parameter struct {
	Name             string                   `json:"name"`
	In               ParameterInType          `json:"in"`
	Description      string                   `json:"description,omitempty"`
	Required         string                   `json:"required"`
	Schema           Schema                   `json:"schema,omitempty"`
	Type             string                   `json:"type,omitempty"`
	Format           string                   `json:"format,omitempty"`
	AllowEmptyValue  string                   `json:"allowEmptyValue,omitempty"`
	Items            Items                    `json:"items,omitempty"`
	CollectionFormat CollectionFormatType     `json:"collectionFormat,omitempty"`
	Default          map[string]interface{}   `json:"default,omitempty"`
	Maximum          int64                    `json:"maximum,omitempty"`
	ExclusiveMaximum string                   `json:"exclusiveMaximum,omitempty"`
	Minimum          int64                    `json:"minimum,omitempty"`
	ExclusiveMinimum string                   `json:"exclusiveMinimum,omitempty"`
	MaxLength        int32                    `json:"maxLength,omitempty"`
	MinLength        int32                    `json:"minLength,omitempty"`
	Pattern          string                   `json:"pattern,omitempty"`
	MaxItems         int32                    `json:"maxItems,omitempty"`
	MinItems         int32                    `json:"minItems,omitempty"`
	UniqueItems      string                   `json:"uniqueItems,omitempty"`
	Enum             []map[string]interface{} `json:"enum,omitempty"`
	MultipleOf       int64                    `json:"multipleOf,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 PathItem struct {
	Ref        string           `json:"ref,omitempty"`
	Get        Operation        `json:"get,omitempty"`
	Put        Operation        `json:"put,omitempty"`
	Post       Operation        `json:"post,omitempty"`
	Delete     Operation        `json:"delete,omitempty"`
	Options    Operation        `json:"options,omitempty"`
	Head       Operation        `json:"head,omitempty"`
	Patch      Operation        `json:"patch,omitempty"`
	Parameters []ParameterOrRef `json:"parameters,omitempty"`
}

func PathItemFromMap(data interface{}) PathItem {
	b, err := json.Marshal(data)
	if err == nil {
		return PathItemFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func PathItemFromJson(bytes io.Reader) PathItem {
	var pathItem PathItem
	json.NewDecoder(bytes).Decode(&pathItem)
	return pathItem
}

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

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 Response struct {
	Description string                 `json:"description"`
	Schema      Schema                 `json:"schema,omitempty"`
	Headers     map[string]Header      `json:"headers,omitempty"`
	Examples    map[string]interface{} `json:"examples,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 Schema struct {
	Ref                  string                   `json:"ref,omitempty"`
	Format               FormatType               `json:"format,omitempty"`
	Title                string                   `json:"title,omitempty"`
	Description          string                   `json:"description,omitempty"`
	Default              map[string]interface{}   `json:"default,omitempty"`
	MultipleOf           int64                    `json:"multipleOf,omitempty"`
	Maximum              int64                    `json:"maximum,omitempty"`
	ExclusiveMaximum     string                   `json:"exclusiveMaximum,omitempty"`
	Minimum              int64                    `json:"minimum,omitempty"`
	ExclusiveMinimum     string                   `json:"exclusiveMinimum,omitempty"`
	MaxLength            int32                    `json:"maxLength,omitempty"`
	MinLength            int32                    `json:"minLength,omitempty"`
	Pattern              string                   `json:"pattern,omitempty"`
	MaxItems             int32                    `json:"maxItems,omitempty"`
	MinItems             int32                    `json:"minItems,omitempty"`
	UniqueItems          string                   `json:"uniqueItems,omitempty"`
	MaxProperties        int32                    `json:"maxProperties,omitempty"`
	MinProperties        int32                    `json:"minProperties,omitempty"`
	Required             []string                 `json:"required,omitempty"`
	Enum                 []map[string]interface{} `json:"enum,omitempty"`
	Type                 []string                 `json:"type,omitempty"`
	Items                Schema                   `json:"items,omitempty"`
	AllOf                []Schema                 `json:"allOf,omitempty"`
	Properties           map[string]Schema        `json:"properties,omitempty"`
	AdditionalProperties Schema                   `json:"additionalProperties,omitempty"`
	Discriminator        string                   `json:"discriminator,omitempty"`
	ReadOnly             string                   `json:"readOnly,omitempty"`
	Xml                  Xml                      `json:"xml,omitempty"`
	ExternalDocs         ExternalDocumentation    `json:"externalDocs,omitempty"`
	Example              map[string]interface{}   `json:"example,omitempty"`
}

func SchemaFromMap(data interface{}) Schema {
	b, err := json.Marshal(data)
	if err == nil {
		return SchemaFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func SchemaFromJson(bytes io.Reader) Schema {
	var schema Schema
	json.NewDecoder(bytes).Decode(&schema)
	return schema
}

/**
 * TODO: Consider making this a union type of the three different schemes (and
 * their required fields)
 */
type SecurityScheme struct {
	Type             SecuritySchemeType `json:"type"`
	Description      string             `json:"description,omitempty"`
	Name             string             `json:"name,omitempty"`
	In               ApiKeyInType       `json:"in,omitempty"`
	Flow             string             `json:"flow,omitempty"`
	AuthorizationUrl string             `json:"authorizationUrl,omitempty"`
	TokenUrl         string             `json:"tokenUrl,omitempty"`
	Scopes           map[string]string  `json:"scopes,omitempty"`
}

func SecuritySchemeFromMap(data interface{}) SecurityScheme {
	b, err := json.Marshal(data)
	if err == nil {
		return SecuritySchemeFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func SecuritySchemeFromJson(bytes io.Reader) SecurityScheme {
	var securityScheme SecurityScheme
	json.NewDecoder(bytes).Decode(&securityScheme)
	return securityScheme
}

type Swagger struct {
	Swagger             string                    `json:"swagger"`
	Info                Info                      `json:"info"`
	Host                string                    `json:"host,omitempty"`
	BasePath            string                    `json:"basePath,omitempty"`
	Schemes             []string                  `json:"schemes,omitempty"`
	Consumes            []string                  `json:"consumes,omitempty"`
	Produces            []string                  `json:"produces,omitempty"`
	Paths               map[string]PathItem       `json:"paths"`
	Definitions         map[string]Schema         `json:"definitions,omitempty"`
	Parameters          map[string]Parameter      `json:"parameters,omitempty"`
	Responses           map[string]Response       `json:"responses,omitempty"`
	SecurityDefinitions map[string]SecurityScheme `json:"securityDefinitions,omitempty"`
	Security            map[string]string         `json:"security,omitempty"`
	Tags                []Tag                     `json:"tags,omitempty"`
	ExternalDocs        ExternalDocumentation     `json:"externalDocs,omitempty"`
}

func SwaggerFromMap(data interface{}) Swagger {
	b, err := json.Marshal(data)
	if err == nil {
		return SwaggerFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func SwaggerFromJson(bytes io.Reader) Swagger {
	var swagger Swagger
	json.NewDecoder(bytes).Decode(&swagger)
	return swagger
}

type Tag struct {
	Name         string                `json:"name"`
	Description  string                `json:"description,omitempty"`
	ExternalDocs ExternalDocumentation `json:"externalDocs,omitempty"`
}

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

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

type Xml struct {
	Name      string `json:"name,omitempty"`
	Namespace string `json:"namespace,omitempty"`
	Prefix    string `json:"prefix,omitempty"`
	Attribute string `json:"attribute,omitempty"`
	Wrapped   string `json:"wrapped,omitempty"`
}

func XmlFromMap(data interface{}) Xml {
	b, err := json.Marshal(data)
	if err == nil {
		return XmlFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func XmlFromJson(bytes io.Reader) Xml {
	var xml Xml
	json.NewDecoder(bytes).Decode(&xml)
	return xml
}

type ParameterOrRef struct {
	Parameter Parameter
	Reference Reference
	Undefined string
}

func ParameterOrRefFromMap(data interface{}) ParameterOrRef {
	b, err := json.Marshal(data)
	if err == nil {
		return ParameterOrRefFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ParameterOrRefFromJson(bytes io.Reader) ParameterOrRef {
// TODO: Not yet supported
}

type ResponseOrRef struct {
	Response  Response
	Reference Reference
	Undefined string
}

func ResponseOrRefFromMap(data interface{}) ResponseOrRef {
	b, err := json.Marshal(data)
	if err == nil {
		return ResponseOrRefFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ResponseOrRefFromJson(bytes io.Reader) ResponseOrRef {
// TODO: Not yet supported
}