/**
 * 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/http4s_0_23
 */
package io.apibuilder.swagger.v0.models {

  package object json {
    import io.circe.Decoder._
    import io.circe.Encoder._
    import scala.language.implicitConversions // See below - Make Scala 2.11 Either monadic
    import scala.util.Try
    import io.circe.{Json, JsonObject, Encoder, Decoder, DecodingFailure}
    import io.circe.syntax._
    import io.apibuilder.swagger.v0.models.json._

    // Make Scala 2.11 Either monadic
    private[v0] implicit def eitherOps[A,B](e: Either[A,B]) = cats.implicits.catsSyntaxEither(e)

    private[v0] implicit val decodeUUID: Decoder[_root_.java.util.UUID] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.util.UUID.fromString(str)))

    private[v0] implicit val encodeUUID: Encoder[_root_.java.util.UUID] =
      Encoder.encodeString.contramap[_root_.java.util.UUID](uuid => uuid.toString)

    private[v0] implicit val decodeInstant: Decoder[_root_.java.time.Instant] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.time.OffsetDateTime.parse(str).toInstant))

    private[v0] implicit val encodeInstant: Encoder[_root_.java.time.Instant] =
      Encoder.encodeString.contramap[_root_.java.time.Instant](_.toString)

    private[v0] implicit val decodeLocalDate: Decoder[_root_.java.time.LocalDate] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.time.LocalDate.parse(str)))

    private[v0] implicit val encodeLocalDate: Encoder[_root_.java.time.LocalDate] =
      Encoder.encodeString.contramap[_root_.java.time.LocalDate](_.toString)

    implicit val jsonDecoderApibuilderSwaggerApiKeyInType: Decoder[io.apibuilder.swagger.v0.models.ApiKeyInType] =
      Decoder.decodeString.map(io.apibuilder.swagger.v0.models.ApiKeyInType(_))

    implicit val jsonEncoderApibuilderSwaggerApiKeyInType: Encoder[io.apibuilder.swagger.v0.models.ApiKeyInType] =
      Encoder.encodeString.contramap[io.apibuilder.swagger.v0.models.ApiKeyInType](_.toString)

    implicit val jsonDecoderApibuilderSwaggerCollectionFormatType: Decoder[io.apibuilder.swagger.v0.models.CollectionFormatType] =
      Decoder.decodeString.map(io.apibuilder.swagger.v0.models.CollectionFormatType(_))

    implicit val jsonEncoderApibuilderSwaggerCollectionFormatType: Encoder[io.apibuilder.swagger.v0.models.CollectionFormatType] =
      Encoder.encodeString.contramap[io.apibuilder.swagger.v0.models.CollectionFormatType](_.toString)

    implicit val jsonDecoderApibuilderSwaggerFormatType: Decoder[io.apibuilder.swagger.v0.models.FormatType] =
      Decoder.decodeString.map(io.apibuilder.swagger.v0.models.FormatType(_))

    implicit val jsonEncoderApibuilderSwaggerFormatType: Encoder[io.apibuilder.swagger.v0.models.FormatType] =
      Encoder.encodeString.contramap[io.apibuilder.swagger.v0.models.FormatType](_.toString)

    implicit val jsonDecoderApibuilderSwaggerItemsType: Decoder[io.apibuilder.swagger.v0.models.ItemsType] =
      Decoder.decodeString.map(io.apibuilder.swagger.v0.models.ItemsType(_))

    implicit val jsonEncoderApibuilderSwaggerItemsType: Encoder[io.apibuilder.swagger.v0.models.ItemsType] =
      Encoder.encodeString.contramap[io.apibuilder.swagger.v0.models.ItemsType](_.toString)

    implicit val jsonDecoderApibuilderSwaggerParameterInType: Decoder[io.apibuilder.swagger.v0.models.ParameterInType] =
      Decoder.decodeString.map(io.apibuilder.swagger.v0.models.ParameterInType(_))

    implicit val jsonEncoderApibuilderSwaggerParameterInType: Encoder[io.apibuilder.swagger.v0.models.ParameterInType] =
      Encoder.encodeString.contramap[io.apibuilder.swagger.v0.models.ParameterInType](_.toString)

    implicit val jsonDecoderApibuilderSwaggerSecuritySchemeType: Decoder[io.apibuilder.swagger.v0.models.SecuritySchemeType] =
      Decoder.decodeString.map(io.apibuilder.swagger.v0.models.SecuritySchemeType(_))

    implicit val jsonEncoderApibuilderSwaggerSecuritySchemeType: Encoder[io.apibuilder.swagger.v0.models.SecuritySchemeType] =
      Encoder.encodeString.contramap[io.apibuilder.swagger.v0.models.SecuritySchemeType](_.toString)

    implicit def decodeApibuilderSwaggerContact: Decoder[Contact] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[Option[String]]
        url <- c.downField("url").as[Option[String]]
        email <- c.downField("email").as[Option[String]]
      } yield {
        Contact(
          name = name,
          url = url,
          email = email
        )
      }
    }

    implicit def encodeApibuilderSwaggerContact: Encoder[Contact] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.name.map(t => "name" -> t.asJson),
        t.url.map(t => "url" -> t.asJson),
        t.email.map(t => "email" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSwaggerExternalDocumentation: Decoder[ExternalDocumentation] = Decoder.instance { c =>
     for {
        description <- c.downField("description").as[Option[String]]
        url <- c.downField("url").as[String]
      } yield {
        ExternalDocumentation(
          description = description,
          url = url
        )
      }
    }

    implicit def encodeApibuilderSwaggerExternalDocumentation: Encoder[ExternalDocumentation] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.description.map(t => "description" -> t.asJson),
        Some("url" -> t.url.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSwaggerHeader: Decoder[Header] = Decoder.instance { c =>
     for {
        description <- c.downField("description").as[Option[String]]
        __type__ <- c.downField("type").as[io.apibuilder.swagger.v0.models.ItemsType]
        format <- c.downField("format").as[Option[io.apibuilder.swagger.v0.models.FormatType]]
        items <- c.downField("items").as[Option[io.apibuilder.swagger.v0.models.Items]]
        collectionFormat <- c.downField("collectionFormat").as[Option[io.apibuilder.swagger.v0.models.CollectionFormatType]]
        default <- c.downField("default").as[Option[Map[String, _root_.io.circe.Json]]]
        maximum <- c.downField("maximum").as[Option[Long]]
        exclusiveMaximum <- c.downField("exclusiveMaximum").as[Option[Boolean]]
        minimum <- c.downField("minimum").as[Option[Long]]
        exclusiveMinimum <- c.downField("exclusiveMinimum").as[Option[Boolean]]
        maxLength <- c.downField("maxLength").as[Option[Int]]
        minLength <- c.downField("minLength").as[Option[Int]]
        pattern <- c.downField("pattern").as[Option[String]]
        maxItems <- c.downField("maxItems").as[Option[Int]]
        minItems <- c.downField("minItems").as[Option[Int]]
        uniqueItems <- c.downField("uniqueItems").as[Option[Boolean]]
        __enum__ <- c.downField("enum").as[Option[Seq[Map[String, _root_.io.circe.Json]]]]
        multipleOf <- c.downField("multipleOf").as[Option[Long]]
      } yield {
        Header(
          description = description,
          `type` = __type__,
          format = format,
          items = items,
          collectionFormat = collectionFormat,
          default = default,
          maximum = maximum,
          exclusiveMaximum = exclusiveMaximum,
          minimum = minimum,
          exclusiveMinimum = exclusiveMinimum,
          maxLength = maxLength,
          minLength = minLength,
          pattern = pattern,
          maxItems = maxItems,
          minItems = minItems,
          uniqueItems = uniqueItems,
          `enum` = __enum__,
          multipleOf = multipleOf
        )
      }
    }

    implicit def encodeApibuilderSwaggerHeader: Encoder[Header] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.description.map(t => "description" -> t.asJson),
        Some("type" -> t.`type`.asJson),
        t.format.map(t => "format" -> t.asJson),
        t.items.map(t => "items" -> t.asJson),
        t.collectionFormat.map(t => "collectionFormat" -> t.asJson),
        t.default.map(t => "default" -> t.asJson),
        t.maximum.map(t => "maximum" -> t.asJson),
        t.exclusiveMaximum.map(t => "exclusiveMaximum" -> t.asJson),
        t.minimum.map(t => "minimum" -> t.asJson),
        t.exclusiveMinimum.map(t => "exclusiveMinimum" -> t.asJson),
        t.maxLength.map(t => "maxLength" -> t.asJson),
        t.minLength.map(t => "minLength" -> t.asJson),
        t.pattern.map(t => "pattern" -> t.asJson),
        t.maxItems.map(t => "maxItems" -> t.asJson),
        t.minItems.map(t => "minItems" -> t.asJson),
        t.uniqueItems.map(t => "uniqueItems" -> t.asJson),
        t.`enum`.map(t => "enum" -> t.asJson),
        t.multipleOf.map(t => "multipleOf" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSwaggerInfo: Decoder[Info] = Decoder.instance { c =>
     for {
        title <- c.downField("title").as[String]
        description <- c.downField("description").as[Option[String]]
        termsOfService <- c.downField("termsOfService").as[Option[String]]
        contact <- c.downField("contact").as[Option[io.apibuilder.swagger.v0.models.Contact]]
        license <- c.downField("license").as[Option[io.apibuilder.swagger.v0.models.License]]
        version <- c.downField("version").as[String]
      } yield {
        Info(
          title = title,
          description = description,
          termsOfService = termsOfService,
          contact = contact,
          license = license,
          version = version
        )
      }
    }

    implicit def encodeApibuilderSwaggerInfo: Encoder[Info] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("title" -> t.title.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.termsOfService.map(t => "termsOfService" -> t.asJson),
        t.contact.map(t => "contact" -> t.asJson),
        t.license.map(t => "license" -> t.asJson),
        Some("version" -> t.version.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSwaggerItems: Decoder[Items] = Decoder.instance { c =>
     for {
        __type__ <- c.downField("type").as[io.apibuilder.swagger.v0.models.ItemsType]
        format <- c.downField("format").as[Option[io.apibuilder.swagger.v0.models.FormatType]]
        items <- c.downField("items").as[Option[io.apibuilder.swagger.v0.models.Items]]
        collectionFormat <- c.downField("collectionFormat").as[Option[io.apibuilder.swagger.v0.models.CollectionFormatType]]
        default <- c.downField("default").as[Option[Map[String, _root_.io.circe.Json]]]
        maximum <- c.downField("maximum").as[Option[Long]]
        exclusiveMaximum <- c.downField("exclusiveMaximum").as[Option[Boolean]]
        minimum <- c.downField("minimum").as[Option[Long]]
        exclusiveMinimum <- c.downField("exclusiveMinimum").as[Option[Boolean]]
        maxLength <- c.downField("maxLength").as[Option[Int]]
        minLength <- c.downField("minLength").as[Option[Int]]
        pattern <- c.downField("pattern").as[Option[String]]
        maxItems <- c.downField("maxItems").as[Option[Int]]
        minItems <- c.downField("minItems").as[Option[Int]]
        uniqueItems <- c.downField("uniqueItems").as[Option[Boolean]]
        __enum__ <- c.downField("enum").as[Option[Seq[Map[String, _root_.io.circe.Json]]]]
        multipleOf <- c.downField("multipleOf").as[Option[Long]]
      } yield {
        Items(
          `type` = __type__,
          format = format,
          items = items,
          collectionFormat = collectionFormat,
          default = default,
          maximum = maximum,
          exclusiveMaximum = exclusiveMaximum,
          minimum = minimum,
          exclusiveMinimum = exclusiveMinimum,
          maxLength = maxLength,
          minLength = minLength,
          pattern = pattern,
          maxItems = maxItems,
          minItems = minItems,
          uniqueItems = uniqueItems,
          `enum` = __enum__,
          multipleOf = multipleOf
        )
      }
    }

    implicit def encodeApibuilderSwaggerItems: Encoder[Items] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("type" -> t.`type`.asJson),
        t.format.map(t => "format" -> t.asJson),
        t.items.map(t => "items" -> t.asJson),
        t.collectionFormat.map(t => "collectionFormat" -> t.asJson),
        t.default.map(t => "default" -> t.asJson),
        t.maximum.map(t => "maximum" -> t.asJson),
        t.exclusiveMaximum.map(t => "exclusiveMaximum" -> t.asJson),
        t.minimum.map(t => "minimum" -> t.asJson),
        t.exclusiveMinimum.map(t => "exclusiveMinimum" -> t.asJson),
        t.maxLength.map(t => "maxLength" -> t.asJson),
        t.minLength.map(t => "minLength" -> t.asJson),
        t.pattern.map(t => "pattern" -> t.asJson),
        t.maxItems.map(t => "maxItems" -> t.asJson),
        t.minItems.map(t => "minItems" -> t.asJson),
        t.uniqueItems.map(t => "uniqueItems" -> t.asJson),
        t.`enum`.map(t => "enum" -> t.asJson),
        t.multipleOf.map(t => "multipleOf" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSwaggerLicense: Decoder[License] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        url <- c.downField("url").as[Option[String]]
      } yield {
        License(
          name = name,
          url = url
        )
      }
    }

    implicit def encodeApibuilderSwaggerLicense: Encoder[License] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        t.url.map(t => "url" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSwaggerOperation: Decoder[Operation] = Decoder.instance { c =>
     for {
        tags <- c.downField("tags").as[Option[Seq[String]]]
        summary <- c.downField("summary").as[Option[String]]
        description <- c.downField("description").as[Option[String]]
        externalDocs <- c.downField("externalDocs").as[Option[io.apibuilder.swagger.v0.models.ExternalDocumentation]]
        operationId <- c.downField("operationId").as[Option[String]]
        consumes <- c.downField("consumes").as[Option[Seq[String]]]
        produces <- c.downField("produces").as[Option[Seq[String]]]
        parameters <- c.downField("parameters").as[Option[Seq[io.apibuilder.swagger.v0.models.ParameterOrRef]]]
        responses <- c.downField("responses").as[Map[String, io.apibuilder.swagger.v0.models.ResponseOrRef]]
        schemes <- c.downField("schemes").as[Option[Seq[String]]]
        deprecated <- c.downField("deprecated").as[Option[Boolean]]
        security <- c.downField("security").as[Option[Seq[Map[String, Seq[String]]]]]
      } yield {
        Operation(
          tags = tags,
          summary = summary,
          description = description,
          externalDocs = externalDocs,
          operationId = operationId,
          consumes = consumes,
          produces = produces,
          parameters = parameters,
          responses = responses,
          schemes = schemes,
          deprecated = deprecated,
          security = security
        )
      }
    }

    implicit def encodeApibuilderSwaggerOperation: Encoder[Operation] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.tags.map(t => "tags" -> t.asJson),
        t.summary.map(t => "summary" -> t.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.externalDocs.map(t => "externalDocs" -> t.asJson),
        t.operationId.map(t => "operationId" -> t.asJson),
        t.consumes.map(t => "consumes" -> t.asJson),
        t.produces.map(t => "produces" -> t.asJson),
        t.parameters.map(t => "parameters" -> t.asJson),
        Some("responses" -> t.responses.asJson),
        t.schemes.map(t => "schemes" -> t.asJson),
        t.deprecated.map(t => "deprecated" -> t.asJson),
        t.security.map(t => "security" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSwaggerParameter: Decoder[Parameter] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        in <- c.downField("in").as[io.apibuilder.swagger.v0.models.ParameterInType]
        description <- c.downField("description").as[Option[String]]
        required <- c.downField("required").as[Boolean]
        schema <- c.downField("schema").as[Option[io.apibuilder.swagger.v0.models.Schema]]
        __type__ <- c.downField("type").as[Option[String]]
        format <- c.downField("format").as[Option[String]]
        allowEmptyValue <- c.downField("allowEmptyValue").as[Option[Boolean]]
        items <- c.downField("items").as[Option[io.apibuilder.swagger.v0.models.Items]]
        collectionFormat <- c.downField("collectionFormat").as[Option[io.apibuilder.swagger.v0.models.CollectionFormatType]]
        default <- c.downField("default").as[Option[Map[String, _root_.io.circe.Json]]]
        maximum <- c.downField("maximum").as[Option[Long]]
        exclusiveMaximum <- c.downField("exclusiveMaximum").as[Option[Boolean]]
        minimum <- c.downField("minimum").as[Option[Long]]
        exclusiveMinimum <- c.downField("exclusiveMinimum").as[Option[Boolean]]
        maxLength <- c.downField("maxLength").as[Option[Int]]
        minLength <- c.downField("minLength").as[Option[Int]]
        pattern <- c.downField("pattern").as[Option[String]]
        maxItems <- c.downField("maxItems").as[Option[Int]]
        minItems <- c.downField("minItems").as[Option[Int]]
        uniqueItems <- c.downField("uniqueItems").as[Option[Boolean]]
        __enum__ <- c.downField("enum").as[Option[Seq[Map[String, _root_.io.circe.Json]]]]
        multipleOf <- c.downField("multipleOf").as[Option[Long]]
      } yield {
        Parameter(
          name = name,
          in = in,
          description = description,
          required = required,
          schema = schema,
          `type` = __type__,
          format = format,
          allowEmptyValue = allowEmptyValue,
          items = items,
          collectionFormat = collectionFormat,
          default = default,
          maximum = maximum,
          exclusiveMaximum = exclusiveMaximum,
          minimum = minimum,
          exclusiveMinimum = exclusiveMinimum,
          maxLength = maxLength,
          minLength = minLength,
          pattern = pattern,
          maxItems = maxItems,
          minItems = minItems,
          uniqueItems = uniqueItems,
          `enum` = __enum__,
          multipleOf = multipleOf
        )
      }
    }

    implicit def encodeApibuilderSwaggerParameter: Encoder[Parameter] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("in" -> t.in.asJson),
        t.description.map(t => "description" -> t.asJson),
        Some("required" -> t.required.asJson),
        t.schema.map(t => "schema" -> t.asJson),
        t.`type`.map(t => "type" -> t.asJson),
        t.format.map(t => "format" -> t.asJson),
        t.allowEmptyValue.map(t => "allowEmptyValue" -> t.asJson),
        t.items.map(t => "items" -> t.asJson),
        t.collectionFormat.map(t => "collectionFormat" -> t.asJson),
        t.default.map(t => "default" -> t.asJson),
        t.maximum.map(t => "maximum" -> t.asJson),
        t.exclusiveMaximum.map(t => "exclusiveMaximum" -> t.asJson),
        t.minimum.map(t => "minimum" -> t.asJson),
        t.exclusiveMinimum.map(t => "exclusiveMinimum" -> t.asJson),
        t.maxLength.map(t => "maxLength" -> t.asJson),
        t.minLength.map(t => "minLength" -> t.asJson),
        t.pattern.map(t => "pattern" -> t.asJson),
        t.maxItems.map(t => "maxItems" -> t.asJson),
        t.minItems.map(t => "minItems" -> t.asJson),
        t.uniqueItems.map(t => "uniqueItems" -> t.asJson),
        t.`enum`.map(t => "enum" -> t.asJson),
        t.multipleOf.map(t => "multipleOf" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSwaggerPathItem: Decoder[PathItem] = Decoder.instance { c =>
     for {
        ref <- c.downField("ref").as[Option[String]]
        get <- c.downField("get").as[Option[io.apibuilder.swagger.v0.models.Operation]]
        put <- c.downField("put").as[Option[io.apibuilder.swagger.v0.models.Operation]]
        post <- c.downField("post").as[Option[io.apibuilder.swagger.v0.models.Operation]]
        delete <- c.downField("delete").as[Option[io.apibuilder.swagger.v0.models.Operation]]
        options <- c.downField("options").as[Option[io.apibuilder.swagger.v0.models.Operation]]
        head <- c.downField("head").as[Option[io.apibuilder.swagger.v0.models.Operation]]
        patch <- c.downField("patch").as[Option[io.apibuilder.swagger.v0.models.Operation]]
        parameters <- c.downField("parameters").as[Option[Seq[io.apibuilder.swagger.v0.models.ParameterOrRef]]]
      } yield {
        PathItem(
          ref = ref,
          get = get,
          put = put,
          post = post,
          delete = delete,
          options = options,
          head = head,
          patch = patch,
          parameters = parameters
        )
      }
    }

    implicit def encodeApibuilderSwaggerPathItem: Encoder[PathItem] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.ref.map(t => "ref" -> t.asJson),
        t.get.map(t => "get" -> t.asJson),
        t.put.map(t => "put" -> t.asJson),
        t.post.map(t => "post" -> t.asJson),
        t.delete.map(t => "delete" -> t.asJson),
        t.options.map(t => "options" -> t.asJson),
        t.head.map(t => "head" -> t.asJson),
        t.patch.map(t => "patch" -> t.asJson),
        t.parameters.map(t => "parameters" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSwaggerReference: Decoder[Reference] = Decoder.instance { c =>
     for {
        ref <- c.downField("ref").as[String]
      } yield {
        Reference(
          ref = ref
        )
      }
    }

    implicit def encodeApibuilderSwaggerReference: Encoder[Reference] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("ref" -> t.ref.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSwaggerResponse: Decoder[Response] = Decoder.instance { c =>
     for {
        description <- c.downField("description").as[String]
        schema <- c.downField("schema").as[Option[io.apibuilder.swagger.v0.models.Schema]]
        headers <- c.downField("headers").as[Option[Map[String, io.apibuilder.swagger.v0.models.Header]]]
        examples <- c.downField("examples").as[Option[Map[String, _root_.io.circe.Json]]]
      } yield {
        Response(
          description = description,
          schema = schema,
          headers = headers,
          examples = examples
        )
      }
    }

    implicit def encodeApibuilderSwaggerResponse: Encoder[Response] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("description" -> t.description.asJson),
        t.schema.map(t => "schema" -> t.asJson),
        t.headers.map(t => "headers" -> t.asJson),
        t.examples.map(t => "examples" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSwaggerSchema: Decoder[Schema] = Decoder.instance { c =>
     for {
        ref <- c.downField("ref").as[Option[String]]
        format <- c.downField("format").as[Option[io.apibuilder.swagger.v0.models.FormatType]]
        title <- c.downField("title").as[Option[String]]
        description <- c.downField("description").as[Option[String]]
        default <- c.downField("default").as[Option[Map[String, _root_.io.circe.Json]]]
        multipleOf <- c.downField("multipleOf").as[Option[Long]]
        maximum <- c.downField("maximum").as[Option[Long]]
        exclusiveMaximum <- c.downField("exclusiveMaximum").as[Option[Boolean]]
        minimum <- c.downField("minimum").as[Option[Long]]
        exclusiveMinimum <- c.downField("exclusiveMinimum").as[Option[Boolean]]
        maxLength <- c.downField("maxLength").as[Option[Int]]
        minLength <- c.downField("minLength").as[Option[Int]]
        pattern <- c.downField("pattern").as[Option[String]]
        maxItems <- c.downField("maxItems").as[Option[Int]]
        minItems <- c.downField("minItems").as[Option[Int]]
        uniqueItems <- c.downField("uniqueItems").as[Option[Boolean]]
        maxProperties <- c.downField("maxProperties").as[Option[Int]]
        minProperties <- c.downField("minProperties").as[Option[Int]]
        required <- c.downField("required").as[Option[Seq[String]]]
        __enum__ <- c.downField("enum").as[Option[Seq[Map[String, _root_.io.circe.Json]]]]
        __type__ <- c.downField("type").as[Option[Seq[String]]]
        items <- c.downField("items").as[Option[io.apibuilder.swagger.v0.models.Schema]]
        allOf <- c.downField("allOf").as[Option[Seq[io.apibuilder.swagger.v0.models.Schema]]]
        properties <- c.downField("properties").as[Option[Map[String, io.apibuilder.swagger.v0.models.Schema]]]
        additionalProperties <- c.downField("additionalProperties").as[Option[io.apibuilder.swagger.v0.models.Schema]]
        discriminator <- c.downField("discriminator").as[Option[String]]
        readOnly <- c.downField("readOnly").as[Option[Boolean]]
        xml <- c.downField("xml").as[Option[io.apibuilder.swagger.v0.models.Xml]]
        externalDocs <- c.downField("externalDocs").as[Option[io.apibuilder.swagger.v0.models.ExternalDocumentation]]
        example <- c.downField("example").as[Option[Map[String, _root_.io.circe.Json]]]
      } yield {
        Schema(
          ref = ref,
          format = format,
          title = title,
          description = description,
          default = default,
          multipleOf = multipleOf,
          maximum = maximum,
          exclusiveMaximum = exclusiveMaximum,
          minimum = minimum,
          exclusiveMinimum = exclusiveMinimum,
          maxLength = maxLength,
          minLength = minLength,
          pattern = pattern,
          maxItems = maxItems,
          minItems = minItems,
          uniqueItems = uniqueItems,
          maxProperties = maxProperties,
          minProperties = minProperties,
          required = required,
          `enum` = __enum__,
          `type` = __type__,
          items = items,
          allOf = allOf,
          properties = properties,
          additionalProperties = additionalProperties,
          discriminator = discriminator,
          readOnly = readOnly,
          xml = xml,
          externalDocs = externalDocs,
          example = example
        )
      }
    }

    implicit def encodeApibuilderSwaggerSchema: Encoder[Schema] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.ref.map(t => "ref" -> t.asJson),
        t.format.map(t => "format" -> t.asJson),
        t.title.map(t => "title" -> t.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.default.map(t => "default" -> t.asJson),
        t.multipleOf.map(t => "multipleOf" -> t.asJson),
        t.maximum.map(t => "maximum" -> t.asJson),
        t.exclusiveMaximum.map(t => "exclusiveMaximum" -> t.asJson),
        t.minimum.map(t => "minimum" -> t.asJson),
        t.exclusiveMinimum.map(t => "exclusiveMinimum" -> t.asJson),
        t.maxLength.map(t => "maxLength" -> t.asJson),
        t.minLength.map(t => "minLength" -> t.asJson),
        t.pattern.map(t => "pattern" -> t.asJson),
        t.maxItems.map(t => "maxItems" -> t.asJson),
        t.minItems.map(t => "minItems" -> t.asJson),
        t.uniqueItems.map(t => "uniqueItems" -> t.asJson),
        t.maxProperties.map(t => "maxProperties" -> t.asJson),
        t.minProperties.map(t => "minProperties" -> t.asJson),
        t.required.map(t => "required" -> t.asJson),
        t.`enum`.map(t => "enum" -> t.asJson),
        t.`type`.map(t => "type" -> t.asJson),
        t.items.map(t => "items" -> t.asJson),
        t.allOf.map(t => "allOf" -> t.asJson),
        t.properties.map(t => "properties" -> t.asJson),
        t.additionalProperties.map(t => "additionalProperties" -> t.asJson),
        t.discriminator.map(t => "discriminator" -> t.asJson),
        t.readOnly.map(t => "readOnly" -> t.asJson),
        t.xml.map(t => "xml" -> t.asJson),
        t.externalDocs.map(t => "externalDocs" -> t.asJson),
        t.example.map(t => "example" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSwaggerSecurityScheme: Decoder[SecurityScheme] = Decoder.instance { c =>
     for {
        __type__ <- c.downField("type").as[io.apibuilder.swagger.v0.models.SecuritySchemeType]
        description <- c.downField("description").as[Option[String]]
        name <- c.downField("name").as[Option[String]]
        in <- c.downField("in").as[Option[io.apibuilder.swagger.v0.models.ApiKeyInType]]
        flow <- c.downField("flow").as[Option[String]]
        authorizationUrl <- c.downField("authorizationUrl").as[Option[String]]
        tokenUrl <- c.downField("tokenUrl").as[Option[String]]
        scopes <- c.downField("scopes").as[Option[Map[String, String]]]
      } yield {
        SecurityScheme(
          `type` = __type__,
          description = description,
          name = name,
          in = in,
          flow = flow,
          authorizationUrl = authorizationUrl,
          tokenUrl = tokenUrl,
          scopes = scopes
        )
      }
    }

    implicit def encodeApibuilderSwaggerSecurityScheme: Encoder[SecurityScheme] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("type" -> t.`type`.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.name.map(t => "name" -> t.asJson),
        t.in.map(t => "in" -> t.asJson),
        t.flow.map(t => "flow" -> t.asJson),
        t.authorizationUrl.map(t => "authorizationUrl" -> t.asJson),
        t.tokenUrl.map(t => "tokenUrl" -> t.asJson),
        t.scopes.map(t => "scopes" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSwaggerSwagger: Decoder[Swagger] = Decoder.instance { c =>
     for {
        swagger <- c.downField("swagger").as[String]
        info <- c.downField("info").as[io.apibuilder.swagger.v0.models.Info]
        host <- c.downField("host").as[Option[String]]
        basePath <- c.downField("basePath").as[Option[String]]
        schemes <- c.downField("schemes").as[Option[Seq[String]]]
        consumes <- c.downField("consumes").as[Option[Seq[String]]]
        produces <- c.downField("produces").as[Option[Seq[String]]]
        paths <- c.downField("paths").as[Map[String, io.apibuilder.swagger.v0.models.PathItem]]
        definitions <- c.downField("definitions").as[Option[Map[String, io.apibuilder.swagger.v0.models.Schema]]]
        parameters <- c.downField("parameters").as[Option[Map[String, io.apibuilder.swagger.v0.models.Parameter]]]
        responses <- c.downField("responses").as[Option[Map[String, io.apibuilder.swagger.v0.models.Response]]]
        securityDefinitions <- c.downField("securityDefinitions").as[Option[Map[String, io.apibuilder.swagger.v0.models.SecurityScheme]]]
        security <- c.downField("security").as[Option[Map[String, String]]]
        tags <- c.downField("tags").as[Option[Seq[io.apibuilder.swagger.v0.models.Tag]]]
        externalDocs <- c.downField("externalDocs").as[Option[io.apibuilder.swagger.v0.models.ExternalDocumentation]]
      } yield {
        Swagger(
          swagger = swagger,
          info = info,
          host = host,
          basePath = basePath,
          schemes = schemes,
          consumes = consumes,
          produces = produces,
          paths = paths,
          definitions = definitions,
          parameters = parameters,
          responses = responses,
          securityDefinitions = securityDefinitions,
          security = security,
          tags = tags,
          externalDocs = externalDocs
        )
      }
    }

    implicit def encodeApibuilderSwaggerSwagger: Encoder[Swagger] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("swagger" -> t.swagger.asJson),
        Some("info" -> t.info.asJson),
        t.host.map(t => "host" -> t.asJson),
        t.basePath.map(t => "basePath" -> t.asJson),
        t.schemes.map(t => "schemes" -> t.asJson),
        t.consumes.map(t => "consumes" -> t.asJson),
        t.produces.map(t => "produces" -> t.asJson),
        Some("paths" -> t.paths.asJson),
        t.definitions.map(t => "definitions" -> t.asJson),
        t.parameters.map(t => "parameters" -> t.asJson),
        t.responses.map(t => "responses" -> t.asJson),
        t.securityDefinitions.map(t => "securityDefinitions" -> t.asJson),
        t.security.map(t => "security" -> t.asJson),
        t.tags.map(t => "tags" -> t.asJson),
        t.externalDocs.map(t => "externalDocs" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSwaggerTag: Decoder[Tag] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        description <- c.downField("description").as[Option[String]]
        externalDocs <- c.downField("externalDocs").as[Option[io.apibuilder.swagger.v0.models.ExternalDocumentation]]
      } yield {
        Tag(
          name = name,
          description = description,
          externalDocs = externalDocs
        )
      }
    }

    implicit def encodeApibuilderSwaggerTag: Encoder[Tag] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.externalDocs.map(t => "externalDocs" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSwaggerXml: Decoder[Xml] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[Option[String]]
        namespace <- c.downField("namespace").as[Option[String]]
        prefix <- c.downField("prefix").as[Option[String]]
        attribute <- c.downField("attribute").as[Option[Boolean]]
        wrapped <- c.downField("wrapped").as[Option[Boolean]]
      } yield {
        Xml(
          name = name,
          namespace = namespace,
          prefix = prefix,
          attribute = attribute,
          wrapped = wrapped
        )
      }
    }

    implicit def encodeApibuilderSwaggerXml: Encoder[Xml] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.name.map(t => "name" -> t.asJson),
        t.namespace.map(t => "namespace" -> t.asJson),
        t.prefix.map(t => "prefix" -> t.asJson),
        t.attribute.map(t => "attribute" -> t.asJson),
        t.wrapped.map(t => "wrapped" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSwaggerParameterOrRef: Decoder[ParameterOrRef] = Decoder.instance { c =>
      c.get[io.apibuilder.swagger.v0.models.Parameter]("parameter") orElse
      c.get[io.apibuilder.swagger.v0.models.Reference]("reference") orElse
      Right(io.apibuilder.swagger.v0.models.ParameterOrRefUndefinedType(c.value.toString))
    }

    implicit def encodeApibuilderSwaggerParameterOrRef: Encoder[ParameterOrRef] = Encoder.instance {
      case t: io.apibuilder.swagger.v0.models.Parameter => Json.fromJsonObject(JsonObject.singleton("parameter", t.asJson))
      case t: io.apibuilder.swagger.v0.models.Reference => Json.fromJsonObject(JsonObject.singleton("reference", t.asJson))
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }

    implicit def decodeApibuilderSwaggerResponseOrRef: Decoder[ResponseOrRef] = Decoder.instance { c =>
      c.get[io.apibuilder.swagger.v0.models.Response]("response") orElse
      c.get[io.apibuilder.swagger.v0.models.Reference]("reference") orElse
      Right(io.apibuilder.swagger.v0.models.ResponseOrRefUndefinedType(c.value.toString))
    }

    implicit def encodeApibuilderSwaggerResponseOrRef: Encoder[ResponseOrRef] = Encoder.instance {
      case t: io.apibuilder.swagger.v0.models.Response => Json.fromJsonObject(JsonObject.singleton("response", t.asJson))
      case t: io.apibuilder.swagger.v0.models.Reference => Json.fromJsonObject(JsonObject.singleton("reference", t.asJson))
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }
  }
}