/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.16.53
 * User agent: apibuilder app.apibuilder.io/apicollective/apibuilder-spec/0.16.53/http4s_0_18
 */
package io.apibuilder.spec.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.spec.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 jsonDecoderApibuilderSpecMethod: Decoder[io.apibuilder.spec.v0.models.Method] =
      Decoder.decodeString.map(io.apibuilder.spec.v0.models.Method(_))

    implicit val jsonEncoderApibuilderSpecMethod: Encoder[io.apibuilder.spec.v0.models.Method] =
      Encoder.encodeString.contramap[io.apibuilder.spec.v0.models.Method](_.toString)

    implicit val jsonDecoderApibuilderSpecParameterLocation: Decoder[io.apibuilder.spec.v0.models.ParameterLocation] =
      Decoder.decodeString.map(io.apibuilder.spec.v0.models.ParameterLocation(_))

    implicit val jsonEncoderApibuilderSpecParameterLocation: Encoder[io.apibuilder.spec.v0.models.ParameterLocation] =
      Encoder.encodeString.contramap[io.apibuilder.spec.v0.models.ParameterLocation](_.toString)

    implicit val jsonDecoderApibuilderSpecResponseCodeOption: Decoder[io.apibuilder.spec.v0.models.ResponseCodeOption] =
      Decoder.decodeString.map(io.apibuilder.spec.v0.models.ResponseCodeOption(_))

    implicit val jsonEncoderApibuilderSpecResponseCodeOption: Encoder[io.apibuilder.spec.v0.models.ResponseCodeOption] =
      Encoder.encodeString.contramap[io.apibuilder.spec.v0.models.ResponseCodeOption](_.toString)

    implicit def decodeApibuilderSpecAnnotation: Decoder[Annotation] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        description <- c.downField("description").as[Option[String]]
        deprecation <- c.downField("deprecation").as[Option[io.apibuilder.spec.v0.models.Deprecation]]
      } yield {
        Annotation(
          name = name,
          description = description,
          deprecation = deprecation
        )
      }
    }

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

    implicit def decodeApibuilderSpecApidoc: Decoder[Apidoc] = Decoder.instance { c =>
     for {
        version <- c.downField("version").as[String]
      } yield {
        Apidoc(
          version = version
        )
      }
    }

    implicit def encodeApibuilderSpecApidoc: Encoder[Apidoc] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("version" -> t.version.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecApplication: Decoder[Application] = Decoder.instance { c =>
     for {
        key <- c.downField("key").as[String]
      } yield {
        Application(
          key = key
        )
      }
    }

    implicit def encodeApibuilderSpecApplication: Encoder[Application] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("key" -> t.key.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecAttribute: Decoder[Attribute] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        value <- c.downField("value").as[Map[String, _root_.io.circe.Json]]
        description <- c.downField("description").as[Option[String]]
        deprecation <- c.downField("deprecation").as[Option[io.apibuilder.spec.v0.models.Deprecation]]
      } yield {
        Attribute(
          name = name,
          value = value,
          description = description,
          deprecation = deprecation
        )
      }
    }

    implicit def encodeApibuilderSpecAttribute: Encoder[Attribute] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("value" -> t.value.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.deprecation.map(t => "deprecation" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecBody: Decoder[Body] = Decoder.instance { c =>
     for {
        __type__ <- c.downField("type").as[String]
        description <- c.downField("description").as[Option[String]]
        deprecation <- c.downField("deprecation").as[Option[io.apibuilder.spec.v0.models.Deprecation]]
        attributes <- c.downField("attributes").as[Seq[io.apibuilder.spec.v0.models.Attribute]]
      } yield {
        Body(
          `type` = __type__,
          description = description,
          deprecation = deprecation,
          attributes = attributes
        )
      }
    }

    implicit def encodeApibuilderSpecBody: Encoder[Body] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("type" -> t.`type`.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.deprecation.map(t => "deprecation" -> t.asJson),
        Some("attributes" -> t.attributes.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecContact: 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 encodeApibuilderSpecContact: 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 decodeApibuilderSpecDeprecation: Decoder[Deprecation] = Decoder.instance { c =>
     for {
        description <- c.downField("description").as[Option[String]]
      } yield {
        Deprecation(
          description = description
        )
      }
    }

    implicit def encodeApibuilderSpecDeprecation: Encoder[Deprecation] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecEnum: Decoder[Enum] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        plural <- c.downField("plural").as[String]
        description <- c.downField("description").as[Option[String]]
        deprecation <- c.downField("deprecation").as[Option[io.apibuilder.spec.v0.models.Deprecation]]
        values <- c.downField("values").as[Seq[io.apibuilder.spec.v0.models.EnumValue]]
        attributes <- c.downField("attributes").as[Seq[io.apibuilder.spec.v0.models.Attribute]]
      } yield {
        Enum(
          name = name,
          plural = plural,
          description = description,
          deprecation = deprecation,
          values = values,
          attributes = attributes
        )
      }
    }

    implicit def encodeApibuilderSpecEnum: Encoder[Enum] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("plural" -> t.plural.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.deprecation.map(t => "deprecation" -> t.asJson),
        Some("values" -> t.values.asJson),
        Some("attributes" -> t.attributes.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecEnumValue: Decoder[EnumValue] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        description <- c.downField("description").as[Option[String]]
        deprecation <- c.downField("deprecation").as[Option[io.apibuilder.spec.v0.models.Deprecation]]
        attributes <- c.downField("attributes").as[Seq[io.apibuilder.spec.v0.models.Attribute]]
        value <- c.downField("value").as[Option[String]]
      } yield {
        EnumValue(
          name = name,
          description = description,
          deprecation = deprecation,
          attributes = attributes,
          value = value
        )
      }
    }

    implicit def encodeApibuilderSpecEnumValue: Encoder[EnumValue] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.deprecation.map(t => "deprecation" -> t.asJson),
        Some("attributes" -> t.attributes.asJson),
        t.value.map(t => "value" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecField: Decoder[Field] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        __type__ <- c.downField("type").as[String]
        description <- c.downField("description").as[Option[String]]
        deprecation <- c.downField("deprecation").as[Option[io.apibuilder.spec.v0.models.Deprecation]]
        default <- c.downField("default").as[Option[String]]
        required <- c.downField("required").as[Boolean]
        minimum <- c.downField("minimum").as[Option[Long]]
        maximum <- c.downField("maximum").as[Option[Long]]
        example <- c.downField("example").as[Option[String]]
        attributes <- c.downField("attributes").as[Seq[io.apibuilder.spec.v0.models.Attribute]]
        annotations <- c.downField("annotations").as[Option[Seq[String]]]
      } yield {
        Field(
          name = name,
          `type` = __type__,
          description = description,
          deprecation = deprecation,
          default = default,
          required = required,
          minimum = minimum,
          maximum = maximum,
          example = example,
          attributes = attributes,
          annotations = annotations.getOrElse(Nil)
        )
      }
    }

    implicit def encodeApibuilderSpecField: Encoder[Field] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("type" -> t.`type`.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.deprecation.map(t => "deprecation" -> t.asJson),
        t.default.map(t => "default" -> t.asJson),
        Some("required" -> t.required.asJson),
        t.minimum.map(t => "minimum" -> t.asJson),
        t.maximum.map(t => "maximum" -> t.asJson),
        t.example.map(t => "example" -> t.asJson),
        Some("attributes" -> t.attributes.asJson),
        Some("annotations" -> t.annotations.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecHeader: Decoder[Header] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        __type__ <- c.downField("type").as[String]
        description <- c.downField("description").as[Option[String]]
        deprecation <- c.downField("deprecation").as[Option[io.apibuilder.spec.v0.models.Deprecation]]
        required <- c.downField("required").as[Boolean]
        default <- c.downField("default").as[Option[String]]
        attributes <- c.downField("attributes").as[Seq[io.apibuilder.spec.v0.models.Attribute]]
      } yield {
        Header(
          name = name,
          `type` = __type__,
          description = description,
          deprecation = deprecation,
          required = required,
          default = default,
          attributes = attributes
        )
      }
    }

    implicit def encodeApibuilderSpecHeader: Encoder[Header] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("type" -> t.`type`.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.deprecation.map(t => "deprecation" -> t.asJson),
        Some("required" -> t.required.asJson),
        t.default.map(t => "default" -> t.asJson),
        Some("attributes" -> t.attributes.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecImport: Decoder[Import] = Decoder.instance { c =>
     for {
        uri <- c.downField("uri").as[String]
        namespace <- c.downField("namespace").as[String]
        organization <- c.downField("organization").as[io.apibuilder.spec.v0.models.Organization]
        application <- c.downField("application").as[io.apibuilder.spec.v0.models.Application]
        version <- c.downField("version").as[String]
        enums <- c.downField("enums").as[Seq[String]]
        interfaces <- c.downField("interfaces").as[Option[Seq[String]]]
        unions <- c.downField("unions").as[Seq[String]]
        models <- c.downField("models").as[Seq[String]]
        annotations <- c.downField("annotations").as[Option[Seq[io.apibuilder.spec.v0.models.Annotation]]]
      } yield {
        Import(
          uri = uri,
          namespace = namespace,
          organization = organization,
          application = application,
          version = version,
          enums = enums,
          interfaces = interfaces.getOrElse(Nil),
          unions = unions,
          models = models,
          annotations = annotations.getOrElse(Nil)
        )
      }
    }

    implicit def encodeApibuilderSpecImport: Encoder[Import] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("uri" -> t.uri.asJson),
        Some("namespace" -> t.namespace.asJson),
        Some("organization" -> t.organization.asJson),
        Some("application" -> t.application.asJson),
        Some("version" -> t.version.asJson),
        Some("enums" -> t.enums.asJson),
        Some("interfaces" -> t.interfaces.asJson),
        Some("unions" -> t.unions.asJson),
        Some("models" -> t.models.asJson),
        Some("annotations" -> t.annotations.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecInfo: Decoder[Info] = Decoder.instance { c =>
     for {
        license <- c.downField("license").as[Option[io.apibuilder.spec.v0.models.License]]
        contact <- c.downField("contact").as[Option[io.apibuilder.spec.v0.models.Contact]]
      } yield {
        Info(
          license = license,
          contact = contact
        )
      }
    }

    implicit def encodeApibuilderSpecInfo: Encoder[Info] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.license.map(t => "license" -> t.asJson),
        t.contact.map(t => "contact" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecInterface: Decoder[Interface] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        plural <- c.downField("plural").as[String]
        description <- c.downField("description").as[Option[String]]
        deprecation <- c.downField("deprecation").as[Option[io.apibuilder.spec.v0.models.Deprecation]]
        fields <- c.downField("fields").as[Seq[io.apibuilder.spec.v0.models.Field]]
        attributes <- c.downField("attributes").as[Seq[io.apibuilder.spec.v0.models.Attribute]]
      } yield {
        Interface(
          name = name,
          plural = plural,
          description = description,
          deprecation = deprecation,
          fields = fields,
          attributes = attributes
        )
      }
    }

    implicit def encodeApibuilderSpecInterface: Encoder[Interface] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("plural" -> t.plural.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.deprecation.map(t => "deprecation" -> t.asJson),
        Some("fields" -> t.fields.asJson),
        Some("attributes" -> t.attributes.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecLicense: 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 encodeApibuilderSpecLicense: Encoder[License] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        t.url.map(t => "url" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecModel: Decoder[Model] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        plural <- c.downField("plural").as[String]
        description <- c.downField("description").as[Option[String]]
        deprecation <- c.downField("deprecation").as[Option[io.apibuilder.spec.v0.models.Deprecation]]
        fields <- c.downField("fields").as[Seq[io.apibuilder.spec.v0.models.Field]]
        attributes <- c.downField("attributes").as[Seq[io.apibuilder.spec.v0.models.Attribute]]
        interfaces <- c.downField("interfaces").as[Option[Seq[String]]]
      } yield {
        Model(
          name = name,
          plural = plural,
          description = description,
          deprecation = deprecation,
          fields = fields,
          attributes = attributes,
          interfaces = interfaces.getOrElse(Nil)
        )
      }
    }

    implicit def encodeApibuilderSpecModel: Encoder[Model] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("plural" -> t.plural.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.deprecation.map(t => "deprecation" -> t.asJson),
        Some("fields" -> t.fields.asJson),
        Some("attributes" -> t.attributes.asJson),
        Some("interfaces" -> t.interfaces.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecOperation: Decoder[Operation] = Decoder.instance { c =>
     for {
        method <- c.downField("method").as[io.apibuilder.spec.v0.models.Method]
        path <- c.downField("path").as[String]
        description <- c.downField("description").as[Option[String]]
        deprecation <- c.downField("deprecation").as[Option[io.apibuilder.spec.v0.models.Deprecation]]
        body <- c.downField("body").as[Option[io.apibuilder.spec.v0.models.Body]]
        parameters <- c.downField("parameters").as[Seq[io.apibuilder.spec.v0.models.Parameter]]
        responses <- c.downField("responses").as[Seq[io.apibuilder.spec.v0.models.Response]]
        attributes <- c.downField("attributes").as[Seq[io.apibuilder.spec.v0.models.Attribute]]
      } yield {
        Operation(
          method = method,
          path = path,
          description = description,
          deprecation = deprecation,
          body = body,
          parameters = parameters,
          responses = responses,
          attributes = attributes
        )
      }
    }

    implicit def encodeApibuilderSpecOperation: Encoder[Operation] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("method" -> t.method.asJson),
        Some("path" -> t.path.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.deprecation.map(t => "deprecation" -> t.asJson),
        t.body.map(t => "body" -> t.asJson),
        Some("parameters" -> t.parameters.asJson),
        Some("responses" -> t.responses.asJson),
        Some("attributes" -> t.attributes.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecOrganization: Decoder[Organization] = Decoder.instance { c =>
     for {
        key <- c.downField("key").as[String]
      } yield {
        Organization(
          key = key
        )
      }
    }

    implicit def encodeApibuilderSpecOrganization: Encoder[Organization] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("key" -> t.key.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecParameter: Decoder[Parameter] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        __type__ <- c.downField("type").as[String]
        location <- c.downField("location").as[io.apibuilder.spec.v0.models.ParameterLocation]
        description <- c.downField("description").as[Option[String]]
        deprecation <- c.downField("deprecation").as[Option[io.apibuilder.spec.v0.models.Deprecation]]
        required <- c.downField("required").as[Boolean]
        default <- c.downField("default").as[Option[String]]
        minimum <- c.downField("minimum").as[Option[Long]]
        maximum <- c.downField("maximum").as[Option[Long]]
        example <- c.downField("example").as[Option[String]]
        attributes <- c.downField("attributes").as[Option[Seq[io.apibuilder.spec.v0.models.Attribute]]]
      } yield {
        Parameter(
          name = name,
          `type` = __type__,
          location = location,
          description = description,
          deprecation = deprecation,
          required = required,
          default = default,
          minimum = minimum,
          maximum = maximum,
          example = example,
          attributes = attributes
        )
      }
    }

    implicit def encodeApibuilderSpecParameter: Encoder[Parameter] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("type" -> t.`type`.asJson),
        Some("location" -> t.location.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.deprecation.map(t => "deprecation" -> t.asJson),
        Some("required" -> t.required.asJson),
        t.default.map(t => "default" -> t.asJson),
        t.minimum.map(t => "minimum" -> t.asJson),
        t.maximum.map(t => "maximum" -> t.asJson),
        t.example.map(t => "example" -> t.asJson),
        t.attributes.map(t => "attributes" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecResource: Decoder[Resource] = Decoder.instance { c =>
     for {
        __type__ <- c.downField("type").as[String]
        plural <- c.downField("plural").as[String]
        path <- c.downField("path").as[Option[String]]
        description <- c.downField("description").as[Option[String]]
        deprecation <- c.downField("deprecation").as[Option[io.apibuilder.spec.v0.models.Deprecation]]
        operations <- c.downField("operations").as[Seq[io.apibuilder.spec.v0.models.Operation]]
        attributes <- c.downField("attributes").as[Seq[io.apibuilder.spec.v0.models.Attribute]]
      } yield {
        Resource(
          `type` = __type__,
          plural = plural,
          path = path,
          description = description,
          deprecation = deprecation,
          operations = operations,
          attributes = attributes
        )
      }
    }

    implicit def encodeApibuilderSpecResource: Encoder[Resource] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("type" -> t.`type`.asJson),
        Some("plural" -> t.plural.asJson),
        t.path.map(t => "path" -> t.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.deprecation.map(t => "deprecation" -> t.asJson),
        Some("operations" -> t.operations.asJson),
        Some("attributes" -> t.attributes.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecResponse: Decoder[Response] = Decoder.instance { c =>
     for {
        code <- c.downField("code").as[io.apibuilder.spec.v0.models.ResponseCode]
        __type__ <- c.downField("type").as[String]
        headers <- c.downField("headers").as[Option[Seq[io.apibuilder.spec.v0.models.Header]]]
        description <- c.downField("description").as[Option[String]]
        deprecation <- c.downField("deprecation").as[Option[io.apibuilder.spec.v0.models.Deprecation]]
        attributes <- c.downField("attributes").as[Option[Seq[io.apibuilder.spec.v0.models.Attribute]]]
      } yield {
        Response(
          code = code,
          `type` = __type__,
          headers = headers,
          description = description,
          deprecation = deprecation,
          attributes = attributes
        )
      }
    }

    implicit def encodeApibuilderSpecResponse: Encoder[Response] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("code" -> t.code.asJson),
        Some("type" -> t.`type`.asJson),
        t.headers.map(t => "headers" -> t.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.deprecation.map(t => "deprecation" -> t.asJson),
        t.attributes.map(t => "attributes" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecService: Decoder[Service] = Decoder.instance { c =>
     for {
        apidoc <- c.downField("apidoc").as[Option[io.apibuilder.spec.v0.models.Apidoc]]
        name <- c.downField("name").as[String]
        organization <- c.downField("organization").as[io.apibuilder.spec.v0.models.Organization]
        application <- c.downField("application").as[io.apibuilder.spec.v0.models.Application]
        namespace <- c.downField("namespace").as[String]
        version <- c.downField("version").as[String]
        baseUrl <- c.downField("base_url").as[Option[String]]
        description <- c.downField("description").as[Option[String]]
        info <- c.downField("info").as[io.apibuilder.spec.v0.models.Info]
        headers <- c.downField("headers").as[Seq[io.apibuilder.spec.v0.models.Header]]
        imports <- c.downField("imports").as[Seq[io.apibuilder.spec.v0.models.Import]]
        enums <- c.downField("enums").as[Seq[io.apibuilder.spec.v0.models.Enum]]
        interfaces <- c.downField("interfaces").as[Option[Seq[io.apibuilder.spec.v0.models.Interface]]]
        unions <- c.downField("unions").as[Seq[io.apibuilder.spec.v0.models.Union]]
        models <- c.downField("models").as[Seq[io.apibuilder.spec.v0.models.Model]]
        resources <- c.downField("resources").as[Seq[io.apibuilder.spec.v0.models.Resource]]
        attributes <- c.downField("attributes").as[Seq[io.apibuilder.spec.v0.models.Attribute]]
        annotations <- c.downField("annotations").as[Option[Seq[io.apibuilder.spec.v0.models.Annotation]]]
      } yield {
        Service(
          apidoc = apidoc,
          name = name,
          organization = organization,
          application = application,
          namespace = namespace,
          version = version,
          baseUrl = baseUrl,
          description = description,
          info = info,
          headers = headers,
          imports = imports,
          enums = enums,
          interfaces = interfaces.getOrElse(Nil),
          unions = unions,
          models = models,
          resources = resources,
          attributes = attributes,
          annotations = annotations.getOrElse(Nil)
        )
      }
    }

    implicit def encodeApibuilderSpecService: Encoder[Service] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.apidoc.map(t => "apidoc" -> t.asJson),
        Some("name" -> t.name.asJson),
        Some("organization" -> t.organization.asJson),
        Some("application" -> t.application.asJson),
        Some("namespace" -> t.namespace.asJson),
        Some("version" -> t.version.asJson),
        t.baseUrl.map(t => "base_url" -> t.asJson),
        t.description.map(t => "description" -> t.asJson),
        Some("info" -> t.info.asJson),
        Some("headers" -> t.headers.asJson),
        Some("imports" -> t.imports.asJson),
        Some("enums" -> t.enums.asJson),
        Some("interfaces" -> t.interfaces.asJson),
        Some("unions" -> t.unions.asJson),
        Some("models" -> t.models.asJson),
        Some("resources" -> t.resources.asJson),
        Some("attributes" -> t.attributes.asJson),
        Some("annotations" -> t.annotations.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecUnion: Decoder[Union] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        plural <- c.downField("plural").as[String]
        discriminator <- c.downField("discriminator").as[Option[String]]
        description <- c.downField("description").as[Option[String]]
        deprecation <- c.downField("deprecation").as[Option[io.apibuilder.spec.v0.models.Deprecation]]
        types <- c.downField("types").as[Seq[io.apibuilder.spec.v0.models.UnionType]]
        attributes <- c.downField("attributes").as[Seq[io.apibuilder.spec.v0.models.Attribute]]
        interfaces <- c.downField("interfaces").as[Option[Seq[String]]]
      } yield {
        Union(
          name = name,
          plural = plural,
          discriminator = discriminator,
          description = description,
          deprecation = deprecation,
          types = types,
          attributes = attributes,
          interfaces = interfaces.getOrElse(Nil)
        )
      }
    }

    implicit def encodeApibuilderSpecUnion: Encoder[Union] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("plural" -> t.plural.asJson),
        t.discriminator.map(t => "discriminator" -> t.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.deprecation.map(t => "deprecation" -> t.asJson),
        Some("types" -> t.types.asJson),
        Some("attributes" -> t.attributes.asJson),
        Some("interfaces" -> t.interfaces.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecUnionType: Decoder[UnionType] = Decoder.instance { c =>
     for {
        __type__ <- c.downField("type").as[String]
        description <- c.downField("description").as[Option[String]]
        deprecation <- c.downField("deprecation").as[Option[io.apibuilder.spec.v0.models.Deprecation]]
        attributes <- c.downField("attributes").as[Seq[io.apibuilder.spec.v0.models.Attribute]]
        default <- c.downField("default").as[Option[Boolean]]
        discriminatorValue <- c.downField("discriminator_value").as[Option[String]]
      } yield {
        UnionType(
          `type` = __type__,
          description = description,
          deprecation = deprecation,
          attributes = attributes,
          default = default,
          discriminatorValue = discriminatorValue
        )
      }
    }

    implicit def encodeApibuilderSpecUnionType: Encoder[UnionType] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("type" -> t.`type`.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.deprecation.map(t => "deprecation" -> t.asJson),
        Some("attributes" -> t.attributes.asJson),
        t.default.map(t => "default" -> t.asJson),
        t.discriminatorValue.map(t => "discriminator_value" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecResponseCodeInt: Decoder[ResponseCodeInt] = Decoder.instance { c =>
     for {
        value <- c.downField("value").as[Int]
      } yield {
        ResponseCodeInt(
          value = value
        )
      }
    }

    implicit def encodeApibuilderSpecResponseCodeInt: Encoder[ResponseCodeInt] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("value" -> t.value.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderSpecResponseCode: Decoder[ResponseCode] = Decoder.instance { c =>
      c.get[io.apibuilder.spec.v0.models.ResponseCodeInt]("integer") orElse
      c.get[io.apibuilder.spec.v0.models.ResponseCodeOption]("response_code_option") orElse
      Right(io.apibuilder.spec.v0.models.ResponseCodeUndefinedType(c.value.toString))
    }

    implicit def encodeApibuilderSpecResponseCode: Encoder[ResponseCode] = Encoder.instance {
      case t: io.apibuilder.spec.v0.models.ResponseCodeInt => Json.fromJsonObject(JsonObject.singleton("integer", t.asJson))
      case t: io.apibuilder.spec.v0.models.ResponseCodeOption => Json.fromJsonObject(JsonObject.singleton("response_code_option", t.asJson))
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }
  }
}