/**
  * Generated by API Builder - https://www.apibuilder.io
  * Service version: 0.16.74
  * User agent: apibuilder app.apibuilder.io/apicollective/apibuilder-api/0.16.74/play_2_6
  */
package io.apibuilder.api.v0.models

package object json {

  import play.api.libs.json.{__, JsString, Writes}
  import play.api.libs.functional.syntax._

  import play.api.libs.json.Writes._
  import play.api.libs.json.Reads._

  import io.apibuilder.api.v0.models.json._
  import io.apibuilder.common.v0.models.json._
  import io.apibuilder.generator.v0.models.json._
  import io.apibuilder.spec.v0.models.json._

  implicit val jsonReadsApibuilderApiAppSortBy: play.api.libs.json.Reads[io.apibuilder.api.v0.models.AppSortBy] =
    new play.api.libs.json.Reads[io.apibuilder.api.v0.models.AppSortBy] {
      def reads(js: play.api.libs.json.JsValue): play.api.libs.json.JsResult[io.apibuilder.api.v0.models.AppSortBy] = {
        js match {
          case v: play.api.libs.json.JsString =>
            play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.AppSortBy(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) =>
                play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.AppSortBy(v))
              case _: play.api.libs.json.JsError =>
                (js \ "app_sort_by").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) =>
                    play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.AppSortBy(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

  def jsonWritesApibuilderApiAppSortBy(obj: io.apibuilder.api.v0.models.AppSortBy) = {
    play.api.libs.json.JsString(obj.toString)
  }

  def jsObjectAppSortBy(obj: io.apibuilder.api.v0.models.AppSortBy) = {
    play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
  }

  implicit def jsonWritesApibuilderApiAppSortBy: play.api.libs.json.Writes[AppSortBy] = {
    (obj: io.apibuilder.api.v0.models.AppSortBy) =>
      {
        io.apibuilder.api.v0.models.json.jsonWritesApibuilderApiAppSortBy(obj)
      }
  }

  implicit val jsonReadsApibuilderApiOriginalType: play.api.libs.json.Reads[io.apibuilder.api.v0.models.OriginalType] =
    new play.api.libs.json.Reads[io.apibuilder.api.v0.models.OriginalType] {
      def reads(
          js: play.api.libs.json.JsValue
      ): play.api.libs.json.JsResult[io.apibuilder.api.v0.models.OriginalType] = {
        js match {
          case v: play.api.libs.json.JsString =>
            play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.OriginalType(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) =>
                play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.OriginalType(v))
              case _: play.api.libs.json.JsError =>
                (js \ "original_type").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) =>
                    play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.OriginalType(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

  def jsonWritesApibuilderApiOriginalType(obj: io.apibuilder.api.v0.models.OriginalType) = {
    play.api.libs.json.JsString(obj.toString)
  }

  def jsObjectOriginalType(obj: io.apibuilder.api.v0.models.OriginalType) = {
    play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
  }

  implicit def jsonWritesApibuilderApiOriginalType: play.api.libs.json.Writes[OriginalType] = {
    (obj: io.apibuilder.api.v0.models.OriginalType) =>
      {
        io.apibuilder.api.v0.models.json.jsonWritesApibuilderApiOriginalType(obj)
      }
  }

  implicit val jsonReadsApibuilderApiPublication: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Publication] =
    new play.api.libs.json.Reads[io.apibuilder.api.v0.models.Publication] {
      def reads(
          js: play.api.libs.json.JsValue
      ): play.api.libs.json.JsResult[io.apibuilder.api.v0.models.Publication] = {
        js match {
          case v: play.api.libs.json.JsString =>
            play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.Publication(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) =>
                play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.Publication(v))
              case _: play.api.libs.json.JsError =>
                (js \ "publication").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) =>
                    play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.Publication(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

  def jsonWritesApibuilderApiPublication(obj: io.apibuilder.api.v0.models.Publication) = {
    play.api.libs.json.JsString(obj.toString)
  }

  def jsObjectPublication(obj: io.apibuilder.api.v0.models.Publication) = {
    play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
  }

  implicit def jsonWritesApibuilderApiPublication: play.api.libs.json.Writes[Publication] = {
    (obj: io.apibuilder.api.v0.models.Publication) =>
      {
        io.apibuilder.api.v0.models.json.jsonWritesApibuilderApiPublication(obj)
      }
  }

  implicit val jsonReadsApibuilderApiSortOrder: play.api.libs.json.Reads[io.apibuilder.api.v0.models.SortOrder] =
    new play.api.libs.json.Reads[io.apibuilder.api.v0.models.SortOrder] {
      def reads(js: play.api.libs.json.JsValue): play.api.libs.json.JsResult[io.apibuilder.api.v0.models.SortOrder] = {
        js match {
          case v: play.api.libs.json.JsString =>
            play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.SortOrder(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) =>
                play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.SortOrder(v))
              case _: play.api.libs.json.JsError =>
                (js \ "sort_order").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) =>
                    play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.SortOrder(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

  def jsonWritesApibuilderApiSortOrder(obj: io.apibuilder.api.v0.models.SortOrder) = {
    play.api.libs.json.JsString(obj.toString)
  }

  def jsObjectSortOrder(obj: io.apibuilder.api.v0.models.SortOrder) = {
    play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
  }

  implicit def jsonWritesApibuilderApiSortOrder: play.api.libs.json.Writes[SortOrder] = {
    (obj: io.apibuilder.api.v0.models.SortOrder) =>
      {
        io.apibuilder.api.v0.models.json.jsonWritesApibuilderApiSortOrder(obj)
      }
  }

  implicit val jsonReadsApibuilderApiVisibility: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Visibility] =
    new play.api.libs.json.Reads[io.apibuilder.api.v0.models.Visibility] {
      def reads(js: play.api.libs.json.JsValue): play.api.libs.json.JsResult[io.apibuilder.api.v0.models.Visibility] = {
        js match {
          case v: play.api.libs.json.JsString =>
            play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.Visibility(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) =>
                play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.Visibility(v))
              case _: play.api.libs.json.JsError =>
                (js \ "visibility").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) =>
                    play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.Visibility(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

  def jsonWritesApibuilderApiVisibility(obj: io.apibuilder.api.v0.models.Visibility) = {
    play.api.libs.json.JsString(obj.toString)
  }

  def jsObjectVisibility(obj: io.apibuilder.api.v0.models.Visibility) = {
    play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
  }

  implicit def jsonWritesApibuilderApiVisibility: play.api.libs.json.Writes[Visibility] = {
    (obj: io.apibuilder.api.v0.models.Visibility) =>
      {
        io.apibuilder.api.v0.models.json.jsonWritesApibuilderApiVisibility(obj)
      }
  }
  implicit def jsonReadsApibuilderApiApplication: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Application] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      organization <- (__ \ "organization").read[io.apibuilder.common.v0.models.Reference]
      name <- (__ \ "name").read[String]
      key <- (__ \ "key").read[String]
      visibility <- (__ \ "visibility").read[io.apibuilder.api.v0.models.Visibility]
      description <- (__ \ "description").readNullable[String]
      lastUpdatedAt <- (__ \ "last_updated_at").read[_root_.java.time.OffsetDateTime]
      audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
    } yield Application(guid, organization, name, key, visibility, description, lastUpdatedAt, audit)
  }

  def jsObjectApplication(obj: io.apibuilder.api.v0.models.Application): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "organization" -> io.apibuilder.common.v0.models.json.jsObjectReference(obj.organization),
      "name" -> play.api.libs.json.JsString(obj.name),
      "key" -> play.api.libs.json.JsString(obj.key),
      "visibility" -> play.api.libs.json.JsString(obj.visibility.toString),
      "last_updated_at" -> play.api.libs.json.JsString(obj.lastUpdatedAt.toString),
      "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
    ) ++ (obj.description match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
    })
  }

  implicit def jsonWritesApibuilderApiApplication: play.api.libs.json.Writes[Application] = {
    (obj: io.apibuilder.api.v0.models.Application) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectApplication(obj)
      }
  }

  implicit def jsonReadsApibuilderApiApplicationForm
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.ApplicationForm] = {
    for {
      name <- (__ \ "name").read[String]
      key <- (__ \ "key").readNullable[String]
      description <- (__ \ "description").readNullable[String]
      visibility <- (__ \ "visibility").read[io.apibuilder.api.v0.models.Visibility]
    } yield ApplicationForm(name, key, description, visibility)
  }

  def jsObjectApplicationForm(obj: io.apibuilder.api.v0.models.ApplicationForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "name" -> play.api.libs.json.JsString(obj.name),
      "visibility" -> play.api.libs.json.JsString(obj.visibility.toString)
    ) ++ (obj.key match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("key" -> play.api.libs.json.JsString(x))
    }) ++
      (obj.description match {
        case None    => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
      })
  }

  implicit def jsonWritesApibuilderApiApplicationForm: play.api.libs.json.Writes[ApplicationForm] = {
    (obj: io.apibuilder.api.v0.models.ApplicationForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectApplicationForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiApplicationMetadata
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.ApplicationMetadata] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      key <- (__ \ "key").read[String]
    } yield ApplicationMetadata(guid, key)
  }

  def jsObjectApplicationMetadata(obj: io.apibuilder.api.v0.models.ApplicationMetadata): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "key" -> play.api.libs.json.JsString(obj.key)
    )
  }

  implicit def jsonWritesApibuilderApiApplicationMetadata: play.api.libs.json.Writes[ApplicationMetadata] = {
    (obj: io.apibuilder.api.v0.models.ApplicationMetadata) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectApplicationMetadata(obj)
      }
  }

  implicit def jsonReadsApibuilderApiApplicationMetadataVersion
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.ApplicationMetadataVersion] = {
    (__ \ "version").read[String].map { x =>
      ApplicationMetadataVersion(version = x)
    }
  }

  def jsObjectApplicationMetadataVersion(
      obj: io.apibuilder.api.v0.models.ApplicationMetadataVersion
  ): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "version" -> play.api.libs.json.JsString(obj.version)
    )
  }

  implicit def jsonWritesApibuilderApiApplicationMetadataVersion
      : play.api.libs.json.Writes[ApplicationMetadataVersion] = {
    (obj: io.apibuilder.api.v0.models.ApplicationMetadataVersion) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectApplicationMetadataVersion(obj)
      }
  }

  implicit def jsonReadsApibuilderApiApplicationSummary
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.ApplicationSummary] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      organization <- (__ \ "organization").read[io.apibuilder.common.v0.models.Reference]
      key <- (__ \ "key").read[String]
    } yield ApplicationSummary(guid, organization, key)
  }

  def jsObjectApplicationSummary(obj: io.apibuilder.api.v0.models.ApplicationSummary): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "organization" -> io.apibuilder.common.v0.models.json.jsObjectReference(obj.organization),
      "key" -> play.api.libs.json.JsString(obj.key)
    ) ++ play.api.libs.json.Json.obj("type" -> "application_summary")
  }

  implicit def jsonWritesApibuilderApiApplicationSummary: play.api.libs.json.Writes[ApplicationSummary] = {
    (obj: io.apibuilder.api.v0.models.ApplicationSummary) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectApplicationSummary(obj)
      }
  }

  implicit def jsonReadsApibuilderApiAttribute: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Attribute] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      name <- (__ \ "name").read[String]
      description <- (__ \ "description").readNullable[String]
      audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
    } yield Attribute(guid, name, description, audit)
  }

  def jsObjectAttribute(obj: io.apibuilder.api.v0.models.Attribute): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "name" -> play.api.libs.json.JsString(obj.name),
      "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
    ) ++ (obj.description match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
    })
  }

  implicit def jsonWritesApibuilderApiAttribute: play.api.libs.json.Writes[Attribute] = {
    (obj: io.apibuilder.api.v0.models.Attribute) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectAttribute(obj)
      }
  }

  implicit def jsonReadsApibuilderApiAttributeForm
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.AttributeForm] = {
    for {
      name <- (__ \ "name").read[String]
      description <- (__ \ "description").readNullable[String]
    } yield AttributeForm(name, description)
  }

  def jsObjectAttributeForm(obj: io.apibuilder.api.v0.models.AttributeForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "name" -> play.api.libs.json.JsString(obj.name)
    ) ++ (obj.description match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
    })
  }

  implicit def jsonWritesApibuilderApiAttributeForm: play.api.libs.json.Writes[AttributeForm] = {
    (obj: io.apibuilder.api.v0.models.AttributeForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectAttributeForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiAttributeSummary
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.AttributeSummary] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      name <- (__ \ "name").read[String]
    } yield AttributeSummary(guid, name)
  }

  def jsObjectAttributeSummary(obj: io.apibuilder.api.v0.models.AttributeSummary): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "name" -> play.api.libs.json.JsString(obj.name)
    )
  }

  implicit def jsonWritesApibuilderApiAttributeSummary: play.api.libs.json.Writes[AttributeSummary] = {
    (obj: io.apibuilder.api.v0.models.AttributeSummary) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectAttributeSummary(obj)
      }
  }

  implicit def jsonReadsApibuilderApiAttributeValue
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.AttributeValue] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      attribute <- (__ \ "attribute").read[io.apibuilder.api.v0.models.AttributeSummary]
      value <- (__ \ "value").read[String]
      audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
    } yield AttributeValue(guid, attribute, value, audit)
  }

  def jsObjectAttributeValue(obj: io.apibuilder.api.v0.models.AttributeValue): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "attribute" -> io.apibuilder.api.v0.models.json.jsObjectAttributeSummary(obj.attribute),
      "value" -> play.api.libs.json.JsString(obj.value),
      "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
    )
  }

  implicit def jsonWritesApibuilderApiAttributeValue: play.api.libs.json.Writes[AttributeValue] = {
    (obj: io.apibuilder.api.v0.models.AttributeValue) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectAttributeValue(obj)
      }
  }

  implicit def jsonReadsApibuilderApiAttributeValueForm
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.AttributeValueForm] = {
    (__ \ "value").read[String].map { x =>
      AttributeValueForm(value = x)
    }
  }

  def jsObjectAttributeValueForm(obj: io.apibuilder.api.v0.models.AttributeValueForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "value" -> play.api.libs.json.JsString(obj.value)
    )
  }

  implicit def jsonWritesApibuilderApiAttributeValueForm: play.api.libs.json.Writes[AttributeValueForm] = {
    (obj: io.apibuilder.api.v0.models.AttributeValueForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectAttributeValueForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiAuthentication
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.Authentication] = {
    for {
      user <- (__ \ "user").read[io.apibuilder.api.v0.models.User]
      session <- (__ \ "session").read[io.apibuilder.api.v0.models.Session]
    } yield Authentication(user, session)
  }

  def jsObjectAuthentication(obj: io.apibuilder.api.v0.models.Authentication): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "user" -> io.apibuilder.api.v0.models.json.jsObjectUser(obj.user),
      "session" -> io.apibuilder.api.v0.models.json.jsObjectSession(obj.session)
    )
  }

  implicit def jsonWritesApibuilderApiAuthentication: play.api.libs.json.Writes[Authentication] = {
    (obj: io.apibuilder.api.v0.models.Authentication) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectAuthentication(obj)
      }
  }

  implicit def jsonReadsApibuilderApiBatchDownloadApplicationForm
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.BatchDownloadApplicationForm] = {
    for {
      applicationKey <- (__ \ "application_key").read[String]
      version <- (__ \ "version").read[String]
    } yield BatchDownloadApplicationForm(applicationKey, version)
  }

  def jsObjectBatchDownloadApplicationForm(
      obj: io.apibuilder.api.v0.models.BatchDownloadApplicationForm
  ): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "application_key" -> play.api.libs.json.JsString(obj.applicationKey),
      "version" -> play.api.libs.json.JsString(obj.version)
    )
  }

  implicit def jsonWritesApibuilderApiBatchDownloadApplicationForm
      : play.api.libs.json.Writes[BatchDownloadApplicationForm] = {
    (obj: io.apibuilder.api.v0.models.BatchDownloadApplicationForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectBatchDownloadApplicationForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiBatchDownloadApplications
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.BatchDownloadApplications] = {
    (__ \ "applications").read[Seq[io.apibuilder.api.v0.models.Version]].map { x =>
      BatchDownloadApplications(applications = x)
    }
  }

  def jsObjectBatchDownloadApplications(
      obj: io.apibuilder.api.v0.models.BatchDownloadApplications
  ): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "applications" -> play.api.libs.json.Json.toJson(obj.applications)
    )
  }

  implicit def jsonWritesApibuilderApiBatchDownloadApplications
      : play.api.libs.json.Writes[BatchDownloadApplications] = {
    (obj: io.apibuilder.api.v0.models.BatchDownloadApplications) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectBatchDownloadApplications(obj)
      }
  }

  implicit def jsonReadsApibuilderApiBatchDownloadApplicationsForm
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.BatchDownloadApplicationsForm] = {
    (__ \ "applications").read[Seq[io.apibuilder.api.v0.models.BatchDownloadApplicationForm]].map { x =>
      BatchDownloadApplicationsForm(applications = x)
    }
  }

  def jsObjectBatchDownloadApplicationsForm(
      obj: io.apibuilder.api.v0.models.BatchDownloadApplicationsForm
  ): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "applications" -> play.api.libs.json.Json.toJson(obj.applications)
    )
  }

  implicit def jsonWritesApibuilderApiBatchDownloadApplicationsForm
      : play.api.libs.json.Writes[BatchDownloadApplicationsForm] = {
    (obj: io.apibuilder.api.v0.models.BatchDownloadApplicationsForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectBatchDownloadApplicationsForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiChange: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Change] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      organization <- (__ \ "organization").read[io.apibuilder.common.v0.models.Reference]
      application <- (__ \ "application").read[io.apibuilder.common.v0.models.Reference]
      fromVersion <- (__ \ "from_version").read[io.apibuilder.api.v0.models.ChangeVersion]
      toVersion <- (__ \ "to_version").read[io.apibuilder.api.v0.models.ChangeVersion]
      diff <- (__ \ "diff").read[io.apibuilder.api.v0.models.Diff]
      changedAt <- (__ \ "changed_at").read[_root_.java.time.OffsetDateTime]
      changedBy <- (__ \ "changed_by").read[io.apibuilder.api.v0.models.UserSummary]
      audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
    } yield Change(guid, organization, application, fromVersion, toVersion, diff, changedAt, changedBy, audit)
  }

  def jsObjectChange(obj: io.apibuilder.api.v0.models.Change): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "organization" -> io.apibuilder.common.v0.models.json.jsObjectReference(obj.organization),
      "application" -> io.apibuilder.common.v0.models.json.jsObjectReference(obj.application),
      "from_version" -> io.apibuilder.api.v0.models.json.jsObjectChangeVersion(obj.fromVersion),
      "to_version" -> io.apibuilder.api.v0.models.json.jsObjectChangeVersion(obj.toVersion),
      "diff" -> io.apibuilder.api.v0.models.json.jsObjectDiff(obj.diff),
      "changed_at" -> play.api.libs.json.JsString(obj.changedAt.toString),
      "changed_by" -> io.apibuilder.api.v0.models.json.jsObjectUserSummary(obj.changedBy),
      "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
    )
  }

  implicit def jsonWritesApibuilderApiChange: play.api.libs.json.Writes[Change] = {
    (obj: io.apibuilder.api.v0.models.Change) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectChange(obj)
      }
  }

  implicit def jsonReadsApibuilderApiChangeVersion
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.ChangeVersion] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      version <- (__ \ "version").read[String]
    } yield ChangeVersion(guid, version)
  }

  def jsObjectChangeVersion(obj: io.apibuilder.api.v0.models.ChangeVersion): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "version" -> play.api.libs.json.JsString(obj.version)
    )
  }

  implicit def jsonWritesApibuilderApiChangeVersion: play.api.libs.json.Writes[ChangeVersion] = {
    (obj: io.apibuilder.api.v0.models.ChangeVersion) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectChangeVersion(obj)
      }
  }

  implicit def jsonReadsApibuilderApiCleartextToken
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.CleartextToken] = {
    (__ \ "token").read[String].map { x =>
      CleartextToken(token = x)
    }
  }

  def jsObjectCleartextToken(obj: io.apibuilder.api.v0.models.CleartextToken): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "token" -> play.api.libs.json.JsString(obj.token)
    )
  }

  implicit def jsonWritesApibuilderApiCleartextToken: play.api.libs.json.Writes[CleartextToken] = {
    (obj: io.apibuilder.api.v0.models.CleartextToken) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectCleartextToken(obj)
      }
  }

  implicit def jsonReadsApibuilderApiCode: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Code] = {
    for {
      generator <- (__ \ "generator").read[io.apibuilder.api.v0.models.GeneratorWithService]
      source <- (__ \ "source").read[String]
      files <- (__ \ "files").read[Seq[io.apibuilder.generator.v0.models.File]]
    } yield Code(generator, source, files)
  }

  def jsObjectCode(obj: io.apibuilder.api.v0.models.Code): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "generator" -> io.apibuilder.api.v0.models.json.jsObjectGeneratorWithService(obj.generator),
      "source" -> play.api.libs.json.JsString(obj.source),
      "files" -> play.api.libs.json.Json.toJson(obj.files)
    )
  }

  implicit def jsonWritesApibuilderApiCode: play.api.libs.json.Writes[Code] = {
    (obj: io.apibuilder.api.v0.models.Code) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectCode(obj)
      }
  }

  implicit def jsonReadsApibuilderApiCodeForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.CodeForm] = {
    (__ \ "attributes").read[Seq[io.apibuilder.generator.v0.models.Attribute]].map { x =>
      CodeForm(attributes = x)
    }
  }

  def jsObjectCodeForm(obj: io.apibuilder.api.v0.models.CodeForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "attributes" -> play.api.libs.json.Json.toJson(obj.attributes)
    )
  }

  implicit def jsonWritesApibuilderApiCodeForm: play.api.libs.json.Writes[CodeForm] = {
    (obj: io.apibuilder.api.v0.models.CodeForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectCodeForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiDiffBreaking
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.DiffBreaking] = {
    for {
      description <- (__ \ "description").read[String]
      isMaterial <- (__ \ "is_material").read[Boolean]
    } yield DiffBreaking(description, isMaterial)
  }

  def jsObjectDiffBreaking(obj: io.apibuilder.api.v0.models.DiffBreaking): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "description" -> play.api.libs.json.JsString(obj.description),
      "is_material" -> play.api.libs.json.JsBoolean(obj.isMaterial)
    ) ++ play.api.libs.json.Json.obj("type" -> "diff_breaking")
  }

  implicit def jsonWritesApibuilderApiDiffBreaking: play.api.libs.json.Writes[DiffBreaking] = {
    (obj: io.apibuilder.api.v0.models.DiffBreaking) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectDiffBreaking(obj)
      }
  }

  implicit def jsonReadsApibuilderApiDiffNonBreaking
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.DiffNonBreaking] = {
    for {
      description <- (__ \ "description").read[String]
      isMaterial <- (__ \ "is_material").read[Boolean]
    } yield DiffNonBreaking(description, isMaterial)
  }

  def jsObjectDiffNonBreaking(obj: io.apibuilder.api.v0.models.DiffNonBreaking): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "description" -> play.api.libs.json.JsString(obj.description),
      "is_material" -> play.api.libs.json.JsBoolean(obj.isMaterial)
    ) ++ play.api.libs.json.Json.obj("type" -> "diff_non_breaking")
  }

  implicit def jsonWritesApibuilderApiDiffNonBreaking: play.api.libs.json.Writes[DiffNonBreaking] = {
    (obj: io.apibuilder.api.v0.models.DiffNonBreaking) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectDiffNonBreaking(obj)
      }
  }

  implicit def jsonReadsApibuilderApiDomain: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Domain] = {
    (__ \ "name").read[String].map { x =>
      Domain(name = x)
    }
  }

  def jsObjectDomain(obj: io.apibuilder.api.v0.models.Domain): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "name" -> play.api.libs.json.JsString(obj.name)
    )
  }

  implicit def jsonWritesApibuilderApiDomain: play.api.libs.json.Writes[Domain] = {
    (obj: io.apibuilder.api.v0.models.Domain) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectDomain(obj)
      }
  }

  implicit def jsonReadsApibuilderApiEmailVerificationConfirmationForm
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.EmailVerificationConfirmationForm] = {
    (__ \ "token").read[String].map { x =>
      EmailVerificationConfirmationForm(token = x)
    }
  }

  def jsObjectEmailVerificationConfirmationForm(
      obj: io.apibuilder.api.v0.models.EmailVerificationConfirmationForm
  ): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "token" -> play.api.libs.json.JsString(obj.token)
    )
  }

  implicit def jsonWritesApibuilderApiEmailVerificationConfirmationForm
      : play.api.libs.json.Writes[EmailVerificationConfirmationForm] = {
    (obj: io.apibuilder.api.v0.models.EmailVerificationConfirmationForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectEmailVerificationConfirmationForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiError: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Error] = {
    for {
      code <- (__ \ "code").read[String]
      message <- (__ \ "message").read[String]
    } yield Error(code, message)
  }

  def jsObjectError(obj: io.apibuilder.api.v0.models.Error): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "code" -> play.api.libs.json.JsString(obj.code),
      "message" -> play.api.libs.json.JsString(obj.message)
    )
  }

  implicit def jsonWritesApibuilderApiError: play.api.libs.json.Writes[Error] = {
    (obj: io.apibuilder.api.v0.models.Error) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectError(obj)
      }
  }

  implicit def jsonReadsApibuilderApiGeneratorForm
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.GeneratorForm] = {
    for {
      serviceGuid <- (__ \ "service_guid").read[_root_.java.util.UUID]
      generator <- (__ \ "generator").read[io.apibuilder.generator.v0.models.Generator]
    } yield GeneratorForm(serviceGuid, generator)
  }

  def jsObjectGeneratorForm(obj: io.apibuilder.api.v0.models.GeneratorForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "service_guid" -> play.api.libs.json.JsString(obj.serviceGuid.toString),
      "generator" -> io.apibuilder.generator.v0.models.json.jsObjectGenerator(obj.generator)
    )
  }

  implicit def jsonWritesApibuilderApiGeneratorForm: play.api.libs.json.Writes[GeneratorForm] = {
    (obj: io.apibuilder.api.v0.models.GeneratorForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectGeneratorForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiGeneratorService
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.GeneratorService] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      uri <- (__ \ "uri").read[String]
      audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
    } yield GeneratorService(guid, uri, audit)
  }

  def jsObjectGeneratorService(obj: io.apibuilder.api.v0.models.GeneratorService): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "uri" -> play.api.libs.json.JsString(obj.uri),
      "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
    )
  }

  implicit def jsonWritesApibuilderApiGeneratorService: play.api.libs.json.Writes[GeneratorService] = {
    (obj: io.apibuilder.api.v0.models.GeneratorService) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectGeneratorService(obj)
      }
  }

  implicit def jsonReadsApibuilderApiGeneratorServiceForm
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.GeneratorServiceForm] = {
    (__ \ "uri").read[String].map { x =>
      GeneratorServiceForm(uri = x)
    }
  }

  def jsObjectGeneratorServiceForm(
      obj: io.apibuilder.api.v0.models.GeneratorServiceForm
  ): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "uri" -> play.api.libs.json.JsString(obj.uri)
    )
  }

  implicit def jsonWritesApibuilderApiGeneratorServiceForm: play.api.libs.json.Writes[GeneratorServiceForm] = {
    (obj: io.apibuilder.api.v0.models.GeneratorServiceForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectGeneratorServiceForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiGeneratorWithService
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.GeneratorWithService] = {
    for {
      service <- (__ \ "service").read[io.apibuilder.api.v0.models.GeneratorService]
      generator <- (__ \ "generator").read[io.apibuilder.generator.v0.models.Generator]
    } yield GeneratorWithService(service, generator)
  }

  def jsObjectGeneratorWithService(
      obj: io.apibuilder.api.v0.models.GeneratorWithService
  ): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "service" -> io.apibuilder.api.v0.models.json.jsObjectGeneratorService(obj.service),
      "generator" -> io.apibuilder.generator.v0.models.json.jsObjectGenerator(obj.generator)
    )
  }

  implicit def jsonWritesApibuilderApiGeneratorWithService: play.api.libs.json.Writes[GeneratorWithService] = {
    (obj: io.apibuilder.api.v0.models.GeneratorWithService) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectGeneratorWithService(obj)
      }
  }

  implicit def jsonReadsApibuilderApiItem: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Item] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      detail <- (__ \ "detail").read[io.apibuilder.api.v0.models.ItemDetail]
      label <- (__ \ "label").read[String]
      description <- (__ \ "description").readNullable[String]
    } yield Item(guid, detail, label, description)
  }

  def jsObjectItem(obj: io.apibuilder.api.v0.models.Item): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "detail" -> io.apibuilder.api.v0.models.json.jsObjectItemDetail(obj.detail),
      "label" -> play.api.libs.json.JsString(obj.label)
    ) ++ (obj.description match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
    })
  }

  implicit def jsonWritesApibuilderApiItem: play.api.libs.json.Writes[Item] = {
    (obj: io.apibuilder.api.v0.models.Item) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectItem(obj)
      }
  }

  implicit def jsonReadsApibuilderApiMembership: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Membership] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      user <- (__ \ "user").read[io.apibuilder.api.v0.models.User]
      organization <- (__ \ "organization").read[io.apibuilder.api.v0.models.Organization]
      role <- (__ \ "role").read[io.apibuilder.common.v0.models.MembershipRole]
      audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
    } yield Membership(guid, user, organization, role, audit)
  }

  def jsObjectMembership(obj: io.apibuilder.api.v0.models.Membership): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "user" -> io.apibuilder.api.v0.models.json.jsObjectUser(obj.user),
      "organization" -> io.apibuilder.api.v0.models.json.jsObjectOrganization(obj.organization),
      "role" -> play.api.libs.json.JsString(obj.role.toString),
      "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
    )
  }

  implicit def jsonWritesApibuilderApiMembership: play.api.libs.json.Writes[Membership] = {
    (obj: io.apibuilder.api.v0.models.Membership) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectMembership(obj)
      }
  }

  implicit def jsonReadsApibuilderApiMembershipRequest
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.MembershipRequest] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      user <- (__ \ "user").read[io.apibuilder.api.v0.models.User]
      organization <- (__ \ "organization").read[io.apibuilder.api.v0.models.Organization]
      role <- (__ \ "role").read[io.apibuilder.common.v0.models.MembershipRole]
      audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
    } yield MembershipRequest(guid, user, organization, role, audit)
  }

  def jsObjectMembershipRequest(obj: io.apibuilder.api.v0.models.MembershipRequest): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "user" -> io.apibuilder.api.v0.models.json.jsObjectUser(obj.user),
      "organization" -> io.apibuilder.api.v0.models.json.jsObjectOrganization(obj.organization),
      "role" -> play.api.libs.json.JsString(obj.role.toString),
      "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
    )
  }

  implicit def jsonWritesApibuilderApiMembershipRequest: play.api.libs.json.Writes[MembershipRequest] = {
    (obj: io.apibuilder.api.v0.models.MembershipRequest) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectMembershipRequest(obj)
      }
  }

  implicit def jsonReadsApibuilderApiMoveForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.MoveForm] = {
    (__ \ "org_key").read[String].map { x =>
      MoveForm(orgKey = x)
    }
  }

  def jsObjectMoveForm(obj: io.apibuilder.api.v0.models.MoveForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "org_key" -> play.api.libs.json.JsString(obj.orgKey)
    )
  }

  implicit def jsonWritesApibuilderApiMoveForm: play.api.libs.json.Writes[MoveForm] = {
    (obj: io.apibuilder.api.v0.models.MoveForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectMoveForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiOrganization
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.Organization] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      key <- (__ \ "key").read[String]
      name <- (__ \ "name").read[String]
      namespace <- (__ \ "namespace").read[String]
      visibility <- (__ \ "visibility").read[io.apibuilder.api.v0.models.Visibility]
      domains <- (__ \ "domains").read[Seq[io.apibuilder.api.v0.models.Domain]]
      audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
    } yield Organization(guid, key, name, namespace, visibility, domains, audit)
  }

  def jsObjectOrganization(obj: io.apibuilder.api.v0.models.Organization): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "key" -> play.api.libs.json.JsString(obj.key),
      "name" -> play.api.libs.json.JsString(obj.name),
      "namespace" -> play.api.libs.json.JsString(obj.namespace),
      "visibility" -> play.api.libs.json.JsString(obj.visibility.toString),
      "domains" -> play.api.libs.json.Json.toJson(obj.domains),
      "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
    )
  }

  implicit def jsonWritesApibuilderApiOrganization: play.api.libs.json.Writes[Organization] = {
    (obj: io.apibuilder.api.v0.models.Organization) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectOrganization(obj)
      }
  }

  implicit def jsonReadsApibuilderApiOrganizationForm
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.OrganizationForm] = {
    for {
      name <- (__ \ "name").read[String]
      key <- (__ \ "key").readNullable[String]
      namespace <- (__ \ "namespace").read[String]
      visibility <- (__ \ "visibility").read[io.apibuilder.api.v0.models.Visibility]
      domains <- (__ \ "domains").readNullable[Seq[String]]
    } yield OrganizationForm(name, key, namespace, visibility, domains)
  }

  def jsObjectOrganizationForm(obj: io.apibuilder.api.v0.models.OrganizationForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "name" -> play.api.libs.json.JsString(obj.name),
      "namespace" -> play.api.libs.json.JsString(obj.namespace),
      "visibility" -> play.api.libs.json.JsString(obj.visibility.toString)
    ) ++ (obj.key match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("key" -> play.api.libs.json.JsString(x))
    }) ++
      (obj.domains match {
        case None    => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("domains" -> play.api.libs.json.Json.toJson(x))
      })
  }

  implicit def jsonWritesApibuilderApiOrganizationForm: play.api.libs.json.Writes[OrganizationForm] = {
    (obj: io.apibuilder.api.v0.models.OrganizationForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectOrganizationForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiOriginal: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Original] = {
    for {
      `type` <- (__ \ "type").read[io.apibuilder.api.v0.models.OriginalType]
      data <- (__ \ "data").read[String]
    } yield Original(`type`, data)
  }

  def jsObjectOriginal(obj: io.apibuilder.api.v0.models.Original): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "type" -> play.api.libs.json.JsString(obj.`type`.toString),
      "data" -> play.api.libs.json.JsString(obj.data)
    )
  }

  implicit def jsonWritesApibuilderApiOriginal: play.api.libs.json.Writes[Original] = {
    (obj: io.apibuilder.api.v0.models.Original) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectOriginal(obj)
      }
  }

  implicit def jsonReadsApibuilderApiOriginalForm
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.OriginalForm] = {
    for {
      `type` <- (__ \ "type").readNullable[io.apibuilder.api.v0.models.OriginalType]
      data <- (__ \ "data").read[String]
    } yield OriginalForm(`type`, data)
  }

  def jsObjectOriginalForm(obj: io.apibuilder.api.v0.models.OriginalForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "data" -> play.api.libs.json.JsString(obj.data)
    ) ++ (obj.`type` match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("type" -> play.api.libs.json.JsString(x.toString))
    })
  }

  implicit def jsonWritesApibuilderApiOriginalForm: play.api.libs.json.Writes[OriginalForm] = {
    (obj: io.apibuilder.api.v0.models.OriginalForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectOriginalForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiPasswordReset
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.PasswordReset] = {
    for {
      token <- (__ \ "token").read[String]
      password <- (__ \ "password").read[String]
    } yield PasswordReset(token, password)
  }

  def jsObjectPasswordReset(obj: io.apibuilder.api.v0.models.PasswordReset): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "token" -> play.api.libs.json.JsString(obj.token),
      "password" -> play.api.libs.json.JsString(obj.password)
    )
  }

  implicit def jsonWritesApibuilderApiPasswordReset: play.api.libs.json.Writes[PasswordReset] = {
    (obj: io.apibuilder.api.v0.models.PasswordReset) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectPasswordReset(obj)
      }
  }

  implicit def jsonReadsApibuilderApiPasswordResetRequest
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.PasswordResetRequest] = {
    (__ \ "email").read[String].map { x =>
      PasswordResetRequest(email = x)
    }
  }

  def jsObjectPasswordResetRequest(
      obj: io.apibuilder.api.v0.models.PasswordResetRequest
  ): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "email" -> play.api.libs.json.JsString(obj.email)
    )
  }

  implicit def jsonWritesApibuilderApiPasswordResetRequest: play.api.libs.json.Writes[PasswordResetRequest] = {
    (obj: io.apibuilder.api.v0.models.PasswordResetRequest) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectPasswordResetRequest(obj)
      }
  }

  implicit def jsonReadsApibuilderApiSession: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Session] = {
    for {
      id <- (__ \ "id").read[String]
      expiresAt <- (__ \ "expires_at").read[_root_.java.time.OffsetDateTime]
    } yield Session(id, expiresAt)
  }

  def jsObjectSession(obj: io.apibuilder.api.v0.models.Session): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "id" -> play.api.libs.json.JsString(obj.id),
      "expires_at" -> play.api.libs.json.JsString(obj.expiresAt.toString)
    )
  }

  implicit def jsonWritesApibuilderApiSession: play.api.libs.json.Writes[Session] = {
    (obj: io.apibuilder.api.v0.models.Session) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectSession(obj)
      }
  }

  implicit def jsonReadsApibuilderApiSubscription
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.Subscription] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      organization <- (__ \ "organization").read[io.apibuilder.api.v0.models.Organization]
      user <- (__ \ "user").read[io.apibuilder.api.v0.models.User]
      publication <- (__ \ "publication").read[io.apibuilder.api.v0.models.Publication]
      audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
    } yield Subscription(guid, organization, user, publication, audit)
  }

  def jsObjectSubscription(obj: io.apibuilder.api.v0.models.Subscription): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "organization" -> io.apibuilder.api.v0.models.json.jsObjectOrganization(obj.organization),
      "user" -> io.apibuilder.api.v0.models.json.jsObjectUser(obj.user),
      "publication" -> play.api.libs.json.JsString(obj.publication.toString),
      "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
    )
  }

  implicit def jsonWritesApibuilderApiSubscription: play.api.libs.json.Writes[Subscription] = {
    (obj: io.apibuilder.api.v0.models.Subscription) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectSubscription(obj)
      }
  }

  implicit def jsonReadsApibuilderApiSubscriptionForm
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.SubscriptionForm] = {
    for {
      organizationKey <- (__ \ "organization_key").read[String]
      userGuid <- (__ \ "user_guid").read[_root_.java.util.UUID]
      publication <- (__ \ "publication").read[io.apibuilder.api.v0.models.Publication]
    } yield SubscriptionForm(organizationKey, userGuid, publication)
  }

  def jsObjectSubscriptionForm(obj: io.apibuilder.api.v0.models.SubscriptionForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "organization_key" -> play.api.libs.json.JsString(obj.organizationKey),
      "user_guid" -> play.api.libs.json.JsString(obj.userGuid.toString),
      "publication" -> play.api.libs.json.JsString(obj.publication.toString)
    )
  }

  implicit def jsonWritesApibuilderApiSubscriptionForm: play.api.libs.json.Writes[SubscriptionForm] = {
    (obj: io.apibuilder.api.v0.models.SubscriptionForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectSubscriptionForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiToken: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Token] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      user <- (__ \ "user").read[io.apibuilder.api.v0.models.User]
      maskedToken <- (__ \ "masked_token").read[String]
      description <- (__ \ "description").readNullable[String]
      audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
    } yield Token(guid, user, maskedToken, description, audit)
  }

  def jsObjectToken(obj: io.apibuilder.api.v0.models.Token): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "user" -> io.apibuilder.api.v0.models.json.jsObjectUser(obj.user),
      "masked_token" -> play.api.libs.json.JsString(obj.maskedToken),
      "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
    ) ++ (obj.description match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
    })
  }

  implicit def jsonWritesApibuilderApiToken: play.api.libs.json.Writes[Token] = {
    (obj: io.apibuilder.api.v0.models.Token) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectToken(obj)
      }
  }

  implicit def jsonReadsApibuilderApiTokenForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.TokenForm] = {
    for {
      userGuid <- (__ \ "user_guid").read[_root_.java.util.UUID]
      description <- (__ \ "description").readNullable[String]
    } yield TokenForm(userGuid, description)
  }

  def jsObjectTokenForm(obj: io.apibuilder.api.v0.models.TokenForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "user_guid" -> play.api.libs.json.JsString(obj.userGuid.toString)
    ) ++ (obj.description match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
    })
  }

  implicit def jsonWritesApibuilderApiTokenForm: play.api.libs.json.Writes[TokenForm] = {
    (obj: io.apibuilder.api.v0.models.TokenForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectTokenForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiUser: play.api.libs.json.Reads[io.apibuilder.api.v0.models.User] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      email <- (__ \ "email").read[String]
      nickname <- (__ \ "nickname").read[String]
      name <- (__ \ "name").readNullable[String]
      audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
    } yield User(guid, email, nickname, name, audit)
  }

  def jsObjectUser(obj: io.apibuilder.api.v0.models.User): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "email" -> play.api.libs.json.JsString(obj.email),
      "nickname" -> play.api.libs.json.JsString(obj.nickname),
      "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
    ) ++ (obj.name match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("name" -> play.api.libs.json.JsString(x))
    })
  }

  implicit def jsonWritesApibuilderApiUser: play.api.libs.json.Writes[User] = {
    (obj: io.apibuilder.api.v0.models.User) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectUser(obj)
      }
  }

  implicit def jsonReadsApibuilderApiUserForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.UserForm] = {
    for {
      email <- (__ \ "email").read[String]
      password <- (__ \ "password").read[String]
      nickname <- (__ \ "nickname").readNullable[String]
      name <- (__ \ "name").readNullable[String]
    } yield UserForm(email, password, nickname, name)
  }

  def jsObjectUserForm(obj: io.apibuilder.api.v0.models.UserForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "email" -> play.api.libs.json.JsString(obj.email),
      "password" -> play.api.libs.json.JsString(obj.password)
    ) ++ (obj.nickname match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("nickname" -> play.api.libs.json.JsString(x))
    }) ++
      (obj.name match {
        case None    => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("name" -> play.api.libs.json.JsString(x))
      })
  }

  implicit def jsonWritesApibuilderApiUserForm: play.api.libs.json.Writes[UserForm] = {
    (obj: io.apibuilder.api.v0.models.UserForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectUserForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiUserSummary: play.api.libs.json.Reads[io.apibuilder.api.v0.models.UserSummary] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      nickname <- (__ \ "nickname").read[String]
    } yield UserSummary(guid, nickname)
  }

  def jsObjectUserSummary(obj: io.apibuilder.api.v0.models.UserSummary): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "nickname" -> play.api.libs.json.JsString(obj.nickname)
    )
  }

  implicit def jsonWritesApibuilderApiUserSummary: play.api.libs.json.Writes[UserSummary] = {
    (obj: io.apibuilder.api.v0.models.UserSummary) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectUserSummary(obj)
      }
  }

  implicit def jsonReadsApibuilderApiUserUpdateForm
      : play.api.libs.json.Reads[io.apibuilder.api.v0.models.UserUpdateForm] = {
    for {
      email <- (__ \ "email").read[String]
      nickname <- (__ \ "nickname").read[String]
      name <- (__ \ "name").readNullable[String]
    } yield UserUpdateForm(email, nickname, name)
  }

  def jsObjectUserUpdateForm(obj: io.apibuilder.api.v0.models.UserUpdateForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "email" -> play.api.libs.json.JsString(obj.email),
      "nickname" -> play.api.libs.json.JsString(obj.nickname)
    ) ++ (obj.name match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("name" -> play.api.libs.json.JsString(x))
    })
  }

  implicit def jsonWritesApibuilderApiUserUpdateForm: play.api.libs.json.Writes[UserUpdateForm] = {
    (obj: io.apibuilder.api.v0.models.UserUpdateForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectUserUpdateForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiValidation: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Validation] = {
    for {
      valid <- (__ \ "valid").read[Boolean]
      errors <- (__ \ "errors").read[Seq[String]]
    } yield Validation(valid, errors)
  }

  def jsObjectValidation(obj: io.apibuilder.api.v0.models.Validation): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "valid" -> play.api.libs.json.JsBoolean(obj.valid),
      "errors" -> play.api.libs.json.Json.toJson(obj.errors)
    )
  }

  implicit def jsonWritesApibuilderApiValidation: play.api.libs.json.Writes[Validation] = {
    (obj: io.apibuilder.api.v0.models.Validation) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectValidation(obj)
      }
  }

  implicit def jsonReadsApibuilderApiVersion: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Version] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      organization <- (__ \ "organization").read[io.apibuilder.common.v0.models.Reference]
      application <- (__ \ "application").read[io.apibuilder.common.v0.models.Reference]
      version <- (__ \ "version").read[String]
      original <- (__ \ "original").readNullable[io.apibuilder.api.v0.models.Original]
      service <- (__ \ "service").read[io.apibuilder.spec.v0.models.Service]
      audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
    } yield Version(guid, organization, application, version, original, service, audit)
  }

  def jsObjectVersion(obj: io.apibuilder.api.v0.models.Version): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "organization" -> io.apibuilder.common.v0.models.json.jsObjectReference(obj.organization),
      "application" -> io.apibuilder.common.v0.models.json.jsObjectReference(obj.application),
      "version" -> play.api.libs.json.JsString(obj.version),
      "service" -> io.apibuilder.spec.v0.models.json.jsObjectService(obj.service),
      "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
    ) ++ (obj.original match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("original" -> io.apibuilder.api.v0.models.json.jsObjectOriginal(x))
    })
  }

  implicit def jsonWritesApibuilderApiVersion: play.api.libs.json.Writes[Version] = {
    (obj: io.apibuilder.api.v0.models.Version) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectVersion(obj)
      }
  }

  implicit def jsonReadsApibuilderApiVersionForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.VersionForm] = {
    for {
      originalForm <- (__ \ "original_form").read[io.apibuilder.api.v0.models.OriginalForm]
      visibility <- (__ \ "visibility").readNullable[io.apibuilder.api.v0.models.Visibility]
    } yield VersionForm(originalForm, visibility)
  }

  def jsObjectVersionForm(obj: io.apibuilder.api.v0.models.VersionForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "original_form" -> io.apibuilder.api.v0.models.json.jsObjectOriginalForm(obj.originalForm)
    ) ++ (obj.visibility match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("visibility" -> play.api.libs.json.JsString(x.toString))
    })
  }

  implicit def jsonWritesApibuilderApiVersionForm: play.api.libs.json.Writes[VersionForm] = {
    (obj: io.apibuilder.api.v0.models.VersionForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectVersionForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiWatch: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Watch] = {
    for {
      guid <- (__ \ "guid").read[_root_.java.util.UUID]
      user <- (__ \ "user").read[io.apibuilder.api.v0.models.User]
      organization <- (__ \ "organization").read[io.apibuilder.api.v0.models.Organization]
      application <- (__ \ "application").read[io.apibuilder.api.v0.models.Application]
      audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
    } yield Watch(guid, user, organization, application, audit)
  }

  def jsObjectWatch(obj: io.apibuilder.api.v0.models.Watch): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "guid" -> play.api.libs.json.JsString(obj.guid.toString),
      "user" -> io.apibuilder.api.v0.models.json.jsObjectUser(obj.user),
      "organization" -> io.apibuilder.api.v0.models.json.jsObjectOrganization(obj.organization),
      "application" -> io.apibuilder.api.v0.models.json.jsObjectApplication(obj.application),
      "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
    )
  }

  implicit def jsonWritesApibuilderApiWatch: play.api.libs.json.Writes[Watch] = {
    (obj: io.apibuilder.api.v0.models.Watch) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectWatch(obj)
      }
  }

  implicit def jsonReadsApibuilderApiWatchForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.WatchForm] = {
    for {
      userGuid <- (__ \ "user_guid").read[_root_.java.util.UUID]
      organizationKey <- (__ \ "organization_key").read[String]
      applicationKey <- (__ \ "application_key").read[String]
    } yield WatchForm(userGuid, organizationKey, applicationKey)
  }

  def jsObjectWatchForm(obj: io.apibuilder.api.v0.models.WatchForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "user_guid" -> play.api.libs.json.JsString(obj.userGuid.toString),
      "organization_key" -> play.api.libs.json.JsString(obj.organizationKey),
      "application_key" -> play.api.libs.json.JsString(obj.applicationKey)
    )
  }

  implicit def jsonWritesApibuilderApiWatchForm: play.api.libs.json.Writes[WatchForm] = {
    (obj: io.apibuilder.api.v0.models.WatchForm) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectWatchForm(obj)
      }
  }

  implicit def jsonReadsApibuilderApiDiff: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Diff] =
    (js: play.api.libs.json.JsValue) => {
      def readDiscriminator(discriminator: String) = {
        discriminator match {
          case "diff_breaking"     => io.apibuilder.api.v0.models.json.jsonReadsApibuilderApiDiffBreaking.reads(js)
          case "diff_non_breaking" => io.apibuilder.api.v0.models.json.jsonReadsApibuilderApiDiffNonBreaking.reads(js)
          case other               => play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.DiffUndefinedType(other))
        }
      }
      (js \ "type").validate[String] match {
        case e: play.api.libs.json.JsError           => e
        case s: play.api.libs.json.JsSuccess[String] => readDiscriminator(s.value)
      }
    }

  def jsObjectDiff(obj: io.apibuilder.api.v0.models.Diff): play.api.libs.json.JsObject = {
    obj match {
      case x: io.apibuilder.api.v0.models.DiffBreaking    => io.apibuilder.api.v0.models.json.jsObjectDiffBreaking(x)
      case x: io.apibuilder.api.v0.models.DiffNonBreaking => io.apibuilder.api.v0.models.json.jsObjectDiffNonBreaking(x)
      case other => {
        sys.error(s"The type[${other.getClass.getName}] has no JSON writer")
      }
    }
  }
  implicit def jsonWritesApibuilderApiDiff: play.api.libs.json.Writes[Diff] = {
    (obj: io.apibuilder.api.v0.models.Diff) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectDiff(obj)
      }
  }

  implicit def jsonReadsApibuilderApiItemDetail: play.api.libs.json.Reads[io.apibuilder.api.v0.models.ItemDetail] =
    (js: play.api.libs.json.JsValue) => {
      def readDiscriminator(discriminator: String) = {
        discriminator match {
          case "application_summary" =>
            io.apibuilder.api.v0.models.json.jsonReadsApibuilderApiApplicationSummary.reads(js)
          case other => play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.ItemDetailUndefinedType(other))
        }
      }
      (js \ "type").validate[String] match {
        case e: play.api.libs.json.JsError           => e
        case s: play.api.libs.json.JsSuccess[String] => readDiscriminator(s.value)
      }
    }

  def jsObjectItemDetail(obj: io.apibuilder.api.v0.models.ItemDetail): play.api.libs.json.JsObject = {
    obj match {
      case x: io.apibuilder.api.v0.models.ApplicationSummary =>
        io.apibuilder.api.v0.models.json.jsObjectApplicationSummary(x)
      case other => {
        sys.error(s"The type[${other.getClass.getName}] has no JSON writer")
      }
    }
  }
  implicit def jsonWritesApibuilderApiItemDetail: play.api.libs.json.Writes[ItemDetail] = {
    (obj: io.apibuilder.api.v0.models.ItemDetail) =>
      {
        io.apibuilder.api.v0.models.json.jsObjectItemDetail(obj)
      }
  }

}