/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.0.5
 * User agent: apibuilder app.apibuilder.io/januar/apidoc-api/0.0.5/http4s_0_18
 */
package januar.apidoc.apidoc.api.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 com.bryzek.apidoc.common.v0.models.json._
    import com.bryzek.apidoc.generator.v0.models.json._
    import com.bryzek.apidoc.spec.v0.models.json._
    import januar.apidoc.apidoc.api.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 jsonDecoderApidocApiOriginalType: Decoder[januar.apidoc.apidoc.api.v0.models.OriginalType] =
      Decoder.decodeString.map(januar.apidoc.apidoc.api.v0.models.OriginalType(_))

    implicit val jsonEncoderApidocApiOriginalType: Encoder[januar.apidoc.apidoc.api.v0.models.OriginalType] =
      Encoder.encodeString.contramap[januar.apidoc.apidoc.api.v0.models.OriginalType](_.toString)

    implicit val jsonDecoderApidocApiPublication: Decoder[januar.apidoc.apidoc.api.v0.models.Publication] =
      Decoder.decodeString.map(januar.apidoc.apidoc.api.v0.models.Publication(_))

    implicit val jsonEncoderApidocApiPublication: Encoder[januar.apidoc.apidoc.api.v0.models.Publication] =
      Encoder.encodeString.contramap[januar.apidoc.apidoc.api.v0.models.Publication](_.toString)

    implicit val jsonDecoderApidocApiVisibility: Decoder[januar.apidoc.apidoc.api.v0.models.Visibility] =
      Decoder.decodeString.map(januar.apidoc.apidoc.api.v0.models.Visibility(_))

    implicit val jsonEncoderApidocApiVisibility: Encoder[januar.apidoc.apidoc.api.v0.models.Visibility] =
      Encoder.encodeString.contramap[januar.apidoc.apidoc.api.v0.models.Visibility](_.toString)

    implicit def decodeApidocApiApplication: Decoder[Application] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        organization <- c.downField("organization").as[com.bryzek.apidoc.common.v0.models.Reference]
        name <- c.downField("name").as[String]
        key <- c.downField("key").as[String]
        visibility <- c.downField("visibility").as[januar.apidoc.apidoc.api.v0.models.Visibility]
        description <- c.downField("description").as[Option[String]]
        audit <- c.downField("audit").as[com.bryzek.apidoc.common.v0.models.Audit]
      } yield {
        Application(
          guid = guid,
          organization = organization,
          name = name,
          key = key,
          visibility = visibility,
          description = description,
          audit = audit
        )
      }
    }

    implicit def encodeApidocApiApplication: Encoder[Application] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("organization" -> t.organization.asJson),
        Some("name" -> t.name.asJson),
        Some("key" -> t.key.asJson),
        Some("visibility" -> t.visibility.asJson),
        t.description.map(t => "description" -> t.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiApplicationForm: Decoder[ApplicationForm] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        key <- c.downField("key").as[Option[String]]
        description <- c.downField("description").as[Option[String]]
        visibility <- c.downField("visibility").as[januar.apidoc.apidoc.api.v0.models.Visibility]
      } yield {
        ApplicationForm(
          name = name,
          key = key,
          description = description,
          visibility = visibility
        )
      }
    }

    implicit def encodeApidocApiApplicationForm: Encoder[ApplicationForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        t.key.map(t => "key" -> t.asJson),
        t.description.map(t => "description" -> t.asJson),
        Some("visibility" -> t.visibility.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiApplicationSummary: Decoder[ApplicationSummary] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        organization <- c.downField("organization").as[com.bryzek.apidoc.common.v0.models.Reference]
        key <- c.downField("key").as[String]
      } yield {
        ApplicationSummary(
          guid = guid,
          organization = organization,
          key = key
        )
      }
    }

    implicit def encodeApidocApiApplicationSummary: Encoder[ApplicationSummary] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("organization" -> t.organization.asJson),
        Some("key" -> t.key.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiAttribute: Decoder[Attribute] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        name <- c.downField("name").as[String]
        description <- c.downField("description").as[Option[String]]
        audit <- c.downField("audit").as[com.bryzek.apidoc.common.v0.models.Audit]
      } yield {
        Attribute(
          guid = guid,
          name = name,
          description = description,
          audit = audit
        )
      }
    }

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

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

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

    implicit def decodeApidocApiAttributeSummary: Decoder[AttributeSummary] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        name <- c.downField("name").as[String]
      } yield {
        AttributeSummary(
          guid = guid,
          name = name
        )
      }
    }

    implicit def encodeApidocApiAttributeSummary: Encoder[AttributeSummary] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("name" -> t.name.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiAttributeValue: Decoder[AttributeValue] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        attribute <- c.downField("attribute").as[januar.apidoc.apidoc.api.v0.models.AttributeSummary]
        value <- c.downField("value").as[String]
        radomstuff <- c.downField("radomstuff").as[String]
        radomstuff2 <- c.downField("radomstuff2").as[Option[String]]
        audit <- c.downField("audit").as[com.bryzek.apidoc.common.v0.models.Audit]
      } yield {
        AttributeValue(
          guid = guid,
          attribute = attribute,
          value = value,
          radomstuff = radomstuff,
          radomstuff2 = radomstuff2,
          audit = audit
        )
      }
    }

    implicit def encodeApidocApiAttributeValue: Encoder[AttributeValue] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("attribute" -> t.attribute.asJson),
        Some("value" -> t.value.asJson),
        Some("radomstuff" -> t.radomstuff.asJson),
        t.radomstuff2.map(t => "radomstuff2" -> t.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiAttributeValueForm: Decoder[AttributeValueForm] = Decoder.instance { c =>
     for {
        value <- c.downField("value").as[String]
      } yield {
        AttributeValueForm(
          value = value
        )
      }
    }

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

    implicit def decodeApidocApiChange: Decoder[Change] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        organization <- c.downField("organization").as[com.bryzek.apidoc.common.v0.models.Reference]
        application <- c.downField("application").as[com.bryzek.apidoc.common.v0.models.Reference]
        fromVersion <- c.downField("from_version").as[januar.apidoc.apidoc.api.v0.models.ChangeVersion]
        toVersion <- c.downField("to_version").as[januar.apidoc.apidoc.api.v0.models.ChangeVersion]
        diff <- c.downField("diff").as[januar.apidoc.apidoc.api.v0.models.Diff]
        changedAt <- c.downField("changed_at").as[_root_.java.time.Instant]
        changedBy <- c.downField("changed_by").as[januar.apidoc.apidoc.api.v0.models.UserSummary]
        audit <- c.downField("audit").as[com.bryzek.apidoc.common.v0.models.Audit]
      } yield {
        Change(
          guid = guid,
          organization = organization,
          application = application,
          fromVersion = fromVersion,
          toVersion = toVersion,
          diff = diff,
          changedAt = changedAt,
          changedBy = changedBy,
          audit = audit
        )
      }
    }

    implicit def encodeApidocApiChange: Encoder[Change] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("organization" -> t.organization.asJson),
        Some("application" -> t.application.asJson),
        Some("from_version" -> t.fromVersion.asJson),
        Some("to_version" -> t.toVersion.asJson),
        Some("diff" -> t.diff.asJson),
        Some("changed_at" -> t.changedAt.asJson),
        Some("changed_by" -> t.changedBy.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiChangeVersion: Decoder[ChangeVersion] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        version <- c.downField("version").as[String]
      } yield {
        ChangeVersion(
          guid = guid,
          version = version
        )
      }
    }

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

    implicit def decodeApidocApiCleartextToken: Decoder[CleartextToken] = Decoder.instance { c =>
     for {
        token <- c.downField("token").as[String]
      } yield {
        CleartextToken(
          token = token
        )
      }
    }

    implicit def encodeApidocApiCleartextToken: Encoder[CleartextToken] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("token" -> t.token.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiCode: Decoder[Code] = Decoder.instance { c =>
     for {
        generator <- c.downField("generator").as[januar.apidoc.apidoc.api.v0.models.GeneratorWithService]
        source <- c.downField("source").as[String]
        files <- c.downField("files").as[Seq[com.bryzek.apidoc.generator.v0.models.File]]
      } yield {
        Code(
          generator = generator,
          source = source,
          files = files
        )
      }
    }

    implicit def encodeApidocApiCode: Encoder[Code] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("generator" -> t.generator.asJson),
        Some("source" -> t.source.asJson),
        Some("files" -> t.files.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiDiffBreaking: Decoder[DiffBreaking] = Decoder.instance { c =>
     for {
        description <- c.downField("description").as[String]
      } yield {
        DiffBreaking(
          description = description
        )
      }
    }

    implicit def encodeApidocApiDiffBreaking: Encoder[DiffBreaking] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("description" -> t.description.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiDiffNonBreaking: Decoder[DiffNonBreaking] = Decoder.instance { c =>
     for {
        description <- c.downField("description").as[String]
      } yield {
        DiffNonBreaking(
          description = description
        )
      }
    }

    implicit def encodeApidocApiDiffNonBreaking: Encoder[DiffNonBreaking] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("description" -> t.description.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiDomain: Decoder[Domain] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
      } yield {
        Domain(
          name = name
        )
      }
    }

    implicit def encodeApidocApiDomain: Encoder[Domain] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiEmailVerificationConfirmationForm: Decoder[EmailVerificationConfirmationForm] = Decoder.instance { c =>
     for {
        token <- c.downField("token").as[String]
      } yield {
        EmailVerificationConfirmationForm(
          token = token
        )
      }
    }

    implicit def encodeApidocApiEmailVerificationConfirmationForm: Encoder[EmailVerificationConfirmationForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("token" -> t.token.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiError: Decoder[Error] = Decoder.instance { c =>
     for {
        code <- c.downField("code").as[String]
        message <- c.downField("message").as[String]
      } yield {
        Error(
          code = code,
          message = message
        )
      }
    }

    implicit def encodeApidocApiError: Encoder[Error] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("code" -> t.code.asJson),
        Some("message" -> t.message.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiGeneratorForm: Decoder[GeneratorForm] = Decoder.instance { c =>
     for {
        serviceGuid <- c.downField("service_guid").as[_root_.java.util.UUID]
        generator <- c.downField("generator").as[com.bryzek.apidoc.generator.v0.models.Generator]
      } yield {
        GeneratorForm(
          serviceGuid = serviceGuid,
          generator = generator
        )
      }
    }

    implicit def encodeApidocApiGeneratorForm: Encoder[GeneratorForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("service_guid" -> t.serviceGuid.asJson),
        Some("generator" -> t.generator.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiGeneratorService: Decoder[GeneratorService] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        uri <- c.downField("uri").as[String]
        audit <- c.downField("audit").as[com.bryzek.apidoc.common.v0.models.Audit]
      } yield {
        GeneratorService(
          guid = guid,
          uri = uri,
          audit = audit
        )
      }
    }

    implicit def encodeApidocApiGeneratorService: Encoder[GeneratorService] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("uri" -> t.uri.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiGeneratorServiceForm: Decoder[GeneratorServiceForm] = Decoder.instance { c =>
     for {
        uri <- c.downField("uri").as[String]
      } yield {
        GeneratorServiceForm(
          uri = uri
        )
      }
    }

    implicit def encodeApidocApiGeneratorServiceForm: Encoder[GeneratorServiceForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("uri" -> t.uri.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiGeneratorWithService: Decoder[GeneratorWithService] = Decoder.instance { c =>
     for {
        service <- c.downField("service").as[januar.apidoc.apidoc.api.v0.models.GeneratorService]
        generator <- c.downField("generator").as[com.bryzek.apidoc.generator.v0.models.Generator]
      } yield {
        GeneratorWithService(
          service = service,
          generator = generator
        )
      }
    }

    implicit def encodeApidocApiGeneratorWithService: Encoder[GeneratorWithService] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("service" -> t.service.asJson),
        Some("generator" -> t.generator.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiItem: Decoder[Item] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        detail <- c.downField("detail").as[januar.apidoc.apidoc.api.v0.models.ItemDetail]
        label <- c.downField("label").as[String]
        description <- c.downField("description").as[Option[String]]
      } yield {
        Item(
          guid = guid,
          detail = detail,
          label = label,
          description = description
        )
      }
    }

    implicit def encodeApidocApiItem: Encoder[Item] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("detail" -> t.detail.asJson),
        Some("label" -> t.label.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiMembership: Decoder[Membership] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        user <- c.downField("user").as[januar.apidoc.apidoc.api.v0.models.User]
        organization <- c.downField("organization").as[januar.apidoc.apidoc.api.v0.models.Organization]
        role <- c.downField("role").as[String]
        audit <- c.downField("audit").as[com.bryzek.apidoc.common.v0.models.Audit]
      } yield {
        Membership(
          guid = guid,
          user = user,
          organization = organization,
          role = role,
          audit = audit
        )
      }
    }

    implicit def encodeApidocApiMembership: Encoder[Membership] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("user" -> t.user.asJson),
        Some("organization" -> t.organization.asJson),
        Some("role" -> t.role.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiMembershipRequest: Decoder[MembershipRequest] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        user <- c.downField("user").as[januar.apidoc.apidoc.api.v0.models.User]
        organization <- c.downField("organization").as[januar.apidoc.apidoc.api.v0.models.Organization]
        role <- c.downField("role").as[String]
        audit <- c.downField("audit").as[com.bryzek.apidoc.common.v0.models.Audit]
      } yield {
        MembershipRequest(
          guid = guid,
          user = user,
          organization = organization,
          role = role,
          audit = audit
        )
      }
    }

    implicit def encodeApidocApiMembershipRequest: Encoder[MembershipRequest] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("user" -> t.user.asJson),
        Some("organization" -> t.organization.asJson),
        Some("role" -> t.role.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiMoveForm: Decoder[MoveForm] = Decoder.instance { c =>
     for {
        orgKey <- c.downField("org_key").as[String]
      } yield {
        MoveForm(
          orgKey = orgKey
        )
      }
    }

    implicit def encodeApidocApiMoveForm: Encoder[MoveForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("org_key" -> t.orgKey.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiOrganization: Decoder[Organization] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        key <- c.downField("key").as[String]
        name <- c.downField("name").as[String]
        namespace <- c.downField("namespace").as[String]
        visibility <- c.downField("visibility").as[januar.apidoc.apidoc.api.v0.models.Visibility]
        domains <- c.downField("domains").as[Seq[januar.apidoc.apidoc.api.v0.models.Domain]]
        audit <- c.downField("audit").as[com.bryzek.apidoc.common.v0.models.Audit]
      } yield {
        Organization(
          guid = guid,
          key = key,
          name = name,
          namespace = namespace,
          visibility = visibility,
          domains = domains,
          audit = audit
        )
      }
    }

    implicit def encodeApidocApiOrganization: Encoder[Organization] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("key" -> t.key.asJson),
        Some("name" -> t.name.asJson),
        Some("namespace" -> t.namespace.asJson),
        Some("visibility" -> t.visibility.asJson),
        Some("domains" -> t.domains.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiOrganizationForm: Decoder[OrganizationForm] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        key <- c.downField("key").as[Option[String]]
        namespace <- c.downField("namespace").as[String]
        visibility <- c.downField("visibility").as[januar.apidoc.apidoc.api.v0.models.Visibility]
        domains <- c.downField("domains").as[Option[Seq[String]]]
      } yield {
        OrganizationForm(
          name = name,
          key = key,
          namespace = namespace,
          visibility = visibility,
          domains = domains
        )
      }
    }

    implicit def encodeApidocApiOrganizationForm: Encoder[OrganizationForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        t.key.map(t => "key" -> t.asJson),
        Some("namespace" -> t.namespace.asJson),
        Some("visibility" -> t.visibility.asJson),
        t.domains.map(t => "domains" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiOriginal: Decoder[Original] = Decoder.instance { c =>
     for {
        __type__ <- c.downField("type").as[januar.apidoc.apidoc.api.v0.models.OriginalType]
        data <- c.downField("data").as[String]
      } yield {
        Original(
          `type` = __type__,
          data = data
        )
      }
    }

    implicit def encodeApidocApiOriginal: Encoder[Original] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("type" -> t.`type`.asJson),
        Some("data" -> t.data.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiOriginalForm: Decoder[OriginalForm] = Decoder.instance { c =>
     for {
        __type__ <- c.downField("type").as[Option[januar.apidoc.apidoc.api.v0.models.OriginalType]]
        data <- c.downField("data").as[String]
      } yield {
        OriginalForm(
          `type` = __type__,
          data = data
        )
      }
    }

    implicit def encodeApidocApiOriginalForm: Encoder[OriginalForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.`type`.map(t => "type" -> t.asJson),
        Some("data" -> t.data.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiPasswordReset: Decoder[PasswordReset] = Decoder.instance { c =>
     for {
        token <- c.downField("token").as[String]
        password <- c.downField("password").as[String]
      } yield {
        PasswordReset(
          token = token,
          password = password
        )
      }
    }

    implicit def encodeApidocApiPasswordReset: Encoder[PasswordReset] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("token" -> t.token.asJson),
        Some("password" -> t.password.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiPasswordResetRequest: Decoder[PasswordResetRequest] = Decoder.instance { c =>
     for {
        email <- c.downField("email").as[String]
      } yield {
        PasswordResetRequest(
          email = email
        )
      }
    }

    implicit def encodeApidocApiPasswordResetRequest: Encoder[PasswordResetRequest] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("email" -> t.email.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiPasswordResetSuccess: Decoder[PasswordResetSuccess] = Decoder.instance { c =>
     for {
        userGuid <- c.downField("user_guid").as[_root_.java.util.UUID]
      } yield {
        PasswordResetSuccess(
          userGuid = userGuid
        )
      }
    }

    implicit def encodeApidocApiPasswordResetSuccess: Encoder[PasswordResetSuccess] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("user_guid" -> t.userGuid.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiSubscription: Decoder[Subscription] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        organization <- c.downField("organization").as[januar.apidoc.apidoc.api.v0.models.Organization]
        user <- c.downField("user").as[januar.apidoc.apidoc.api.v0.models.User]
        publication <- c.downField("publication").as[januar.apidoc.apidoc.api.v0.models.Publication]
        audit <- c.downField("audit").as[com.bryzek.apidoc.common.v0.models.Audit]
      } yield {
        Subscription(
          guid = guid,
          organization = organization,
          user = user,
          publication = publication,
          audit = audit
        )
      }
    }

    implicit def encodeApidocApiSubscription: Encoder[Subscription] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("organization" -> t.organization.asJson),
        Some("user" -> t.user.asJson),
        Some("publication" -> t.publication.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiSubscriptionForm: Decoder[SubscriptionForm] = Decoder.instance { c =>
     for {
        organizationKey <- c.downField("organization_key").as[String]
        userGuid <- c.downField("user_guid").as[_root_.java.util.UUID]
        publication <- c.downField("publication").as[januar.apidoc.apidoc.api.v0.models.Publication]
      } yield {
        SubscriptionForm(
          organizationKey = organizationKey,
          userGuid = userGuid,
          publication = publication
        )
      }
    }

    implicit def encodeApidocApiSubscriptionForm: Encoder[SubscriptionForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("organization_key" -> t.organizationKey.asJson),
        Some("user_guid" -> t.userGuid.asJson),
        Some("publication" -> t.publication.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiToken: Decoder[Token] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        user <- c.downField("user").as[januar.apidoc.apidoc.api.v0.models.User]
        maskedToken <- c.downField("masked_token").as[String]
        description <- c.downField("description").as[Option[String]]
        audit <- c.downField("audit").as[com.bryzek.apidoc.common.v0.models.Audit]
      } yield {
        Token(
          guid = guid,
          user = user,
          maskedToken = maskedToken,
          description = description,
          audit = audit
        )
      }
    }

    implicit def encodeApidocApiToken: Encoder[Token] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("user" -> t.user.asJson),
        Some("masked_token" -> t.maskedToken.asJson),
        t.description.map(t => "description" -> t.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiTokenForm: Decoder[TokenForm] = Decoder.instance { c =>
     for {
        userGuid <- c.downField("user_guid").as[_root_.java.util.UUID]
        description <- c.downField("description").as[Option[String]]
      } yield {
        TokenForm(
          userGuid = userGuid,
          description = description
        )
      }
    }

    implicit def encodeApidocApiTokenForm: Encoder[TokenForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("user_guid" -> t.userGuid.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiUser: Decoder[User] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        email <- c.downField("email").as[String]
        nickname <- c.downField("nickname").as[String]
        name <- c.downField("name").as[Option[String]]
        audit <- c.downField("audit").as[com.bryzek.apidoc.common.v0.models.Audit]
      } yield {
        User(
          guid = guid,
          email = email,
          nickname = nickname,
          name = name,
          audit = audit
        )
      }
    }

    implicit def encodeApidocApiUser: Encoder[User] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("email" -> t.email.asJson),
        Some("nickname" -> t.nickname.asJson),
        t.name.map(t => "name" -> t.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiUserForm: Decoder[UserForm] = Decoder.instance { c =>
     for {
        email <- c.downField("email").as[String]
        password <- c.downField("password").as[String]
        nickname <- c.downField("nickname").as[Option[String]]
        name <- c.downField("name").as[Option[String]]
      } yield {
        UserForm(
          email = email,
          password = password,
          nickname = nickname,
          name = name
        )
      }
    }

    implicit def encodeApidocApiUserForm: Encoder[UserForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("email" -> t.email.asJson),
        Some("password" -> t.password.asJson),
        t.nickname.map(t => "nickname" -> t.asJson),
        t.name.map(t => "name" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiUserSummary: Decoder[UserSummary] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        nickname <- c.downField("nickname").as[String]
      } yield {
        UserSummary(
          guid = guid,
          nickname = nickname
        )
      }
    }

    implicit def encodeApidocApiUserSummary: Encoder[UserSummary] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("nickname" -> t.nickname.asJson)
      ).flatten)
    }

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

    implicit def encodeApidocApiUserUpdateForm: Encoder[UserUpdateForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("email" -> t.email.asJson),
        Some("nickname" -> t.nickname.asJson),
        t.name.map(t => "name" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiValidation: Decoder[Validation] = Decoder.instance { c =>
     for {
        valid <- c.downField("valid").as[Boolean]
        errors <- c.downField("errors").as[Seq[String]]
      } yield {
        Validation(
          valid = valid,
          errors = errors
        )
      }
    }

    implicit def encodeApidocApiValidation: Encoder[Validation] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("valid" -> t.valid.asJson),
        Some("errors" -> t.errors.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiVersion: Decoder[Version] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        organization <- c.downField("organization").as[com.bryzek.apidoc.common.v0.models.Reference]
        application <- c.downField("application").as[com.bryzek.apidoc.common.v0.models.Reference]
        version <- c.downField("version").as[String]
        original <- c.downField("original").as[Option[januar.apidoc.apidoc.api.v0.models.Original]]
        service <- c.downField("service").as[com.bryzek.apidoc.spec.v0.models.Service]
        audit <- c.downField("audit").as[com.bryzek.apidoc.common.v0.models.Audit]
      } yield {
        Version(
          guid = guid,
          organization = organization,
          application = application,
          version = version,
          original = original,
          service = service,
          audit = audit
        )
      }
    }

    implicit def encodeApidocApiVersion: Encoder[Version] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("organization" -> t.organization.asJson),
        Some("application" -> t.application.asJson),
        Some("version" -> t.version.asJson),
        t.original.map(t => "original" -> t.asJson),
        Some("service" -> t.service.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiVersionForm: Decoder[VersionForm] = Decoder.instance { c =>
     for {
        originalForm <- c.downField("original_form").as[januar.apidoc.apidoc.api.v0.models.OriginalForm]
        visibility <- c.downField("visibility").as[Option[januar.apidoc.apidoc.api.v0.models.Visibility]]
      } yield {
        VersionForm(
          originalForm = originalForm,
          visibility = visibility
        )
      }
    }

    implicit def encodeApidocApiVersionForm: Encoder[VersionForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("original_form" -> t.originalForm.asJson),
        t.visibility.map(t => "visibility" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiWatch: Decoder[Watch] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        user <- c.downField("user").as[januar.apidoc.apidoc.api.v0.models.User]
        organization <- c.downField("organization").as[januar.apidoc.apidoc.api.v0.models.Organization]
        application <- c.downField("application").as[januar.apidoc.apidoc.api.v0.models.Application]
        audit <- c.downField("audit").as[com.bryzek.apidoc.common.v0.models.Audit]
      } yield {
        Watch(
          guid = guid,
          user = user,
          organization = organization,
          application = application,
          audit = audit
        )
      }
    }

    implicit def encodeApidocApiWatch: Encoder[Watch] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("user" -> t.user.asJson),
        Some("organization" -> t.organization.asJson),
        Some("application" -> t.application.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiWatchForm: Decoder[WatchForm] = Decoder.instance { c =>
     for {
        userGuid <- c.downField("user_guid").as[_root_.java.util.UUID]
        organizationKey <- c.downField("organization_key").as[String]
        applicationKey <- c.downField("application_key").as[String]
      } yield {
        WatchForm(
          userGuid = userGuid,
          organizationKey = organizationKey,
          applicationKey = applicationKey
        )
      }
    }

    implicit def encodeApidocApiWatchForm: Encoder[WatchForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("user_guid" -> t.userGuid.asJson),
        Some("organization_key" -> t.organizationKey.asJson),
        Some("application_key" -> t.applicationKey.asJson)
      ).flatten)
    }

    implicit def decodeApidocApiDiff: Decoder[Diff] = Decoder.instance { c =>
      c.get[Option[String]]("type") match {
        case Right(Some(s)) if s == "diff_breaking" => c.as[januar.apidoc.apidoc.api.v0.models.DiffBreaking]
        case Right(Some(s)) if s == "diff_non_breaking" => c.as[januar.apidoc.apidoc.api.v0.models.DiffNonBreaking]
        case Right(Some(s)) => Right(januar.apidoc.apidoc.api.v0.models.DiffUndefinedType(s))
        case _ => Left(DecodingFailure("Union[Diff] requires a discriminator named 'type' - this field was not found in the Json", c.history))
      }
    }

    implicit def encodeApidocApiDiff: Encoder[Diff] = Encoder.instance {
      case t: januar.apidoc.apidoc.api.v0.models.DiffBreaking => t.asJson.mapObject(obj => ("type", Json.fromString("diff_breaking")) +: obj)
      case t: januar.apidoc.apidoc.api.v0.models.DiffNonBreaking => t.asJson.mapObject(obj => ("type", Json.fromString("diff_non_breaking")) +: obj)
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }

    implicit def decodeApidocApiItemDetail: Decoder[ItemDetail] = Decoder.instance { c =>
      c.get[Option[String]]("type") match {
        case Right(Some(s)) if s == "application_summary" => c.as[januar.apidoc.apidoc.api.v0.models.ApplicationSummary]
        case Right(Some(s)) => Right(januar.apidoc.apidoc.api.v0.models.ItemDetailUndefinedType(s))
        case _ => Left(DecodingFailure("Union[ItemDetail] requires a discriminator named 'type' - this field was not found in the Json", c.history))
      }
    }

    implicit def encodeApidocApiItemDetail: Encoder[ItemDetail] = Encoder.instance {
      case t: januar.apidoc.apidoc.api.v0.models.ApplicationSummary => t.asJson.mapObject(obj => ("type", Json.fromString("application_summary")) +: obj)
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }
  }
}