/**
  * Generated by API Builder - https://www.apibuilder.io
  * Service version: 0.4.67
  * User agent: apibuilder app.apibuilder.io/flow/github/0.4.67/play_2_6
  */
package io.flow.github.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.flow.github.v0.models.json._

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

  def jsonWritesGithubContentsType(obj: io.flow.github.v0.models.ContentsType) = {
    play.api.libs.json.JsString(obj.toString)
  }

  def jsObjectContentsType(obj: io.flow.github.v0.models.ContentsType) = {
    play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
  }

  implicit def jsonWritesGithubContentsType: play.api.libs.json.Writes[ContentsType] = {
    (obj: io.flow.github.v0.models.ContentsType) =>
      {
        io.flow.github.v0.models.json.jsonWritesGithubContentsType(obj)
      }
  }

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

  def jsonWritesGithubEncoding(obj: io.flow.github.v0.models.Encoding) = {
    play.api.libs.json.JsString(obj.toString)
  }

  def jsObjectEncoding(obj: io.flow.github.v0.models.Encoding) = {
    play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
  }

  implicit def jsonWritesGithubEncoding: play.api.libs.json.Writes[Encoding] = {
    (obj: io.flow.github.v0.models.Encoding) =>
      {
        io.flow.github.v0.models.json.jsonWritesGithubEncoding(obj)
      }
  }

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

  def jsonWritesGithubHookEvent(obj: io.flow.github.v0.models.HookEvent) = {
    play.api.libs.json.JsString(obj.toString)
  }

  def jsObjectHookEvent(obj: io.flow.github.v0.models.HookEvent) = {
    play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
  }

  implicit def jsonWritesGithubHookEvent: play.api.libs.json.Writes[HookEvent] = {
    (obj: io.flow.github.v0.models.HookEvent) =>
      {
        io.flow.github.v0.models.json.jsonWritesGithubHookEvent(obj)
      }
  }

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

  def jsonWritesGithubNodeType(obj: io.flow.github.v0.models.NodeType) = {
    play.api.libs.json.JsString(obj.toString)
  }

  def jsObjectNodeType(obj: io.flow.github.v0.models.NodeType) = {
    play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
  }

  implicit def jsonWritesGithubNodeType: play.api.libs.json.Writes[NodeType] = {
    (obj: io.flow.github.v0.models.NodeType) =>
      {
        io.flow.github.v0.models.json.jsonWritesGithubNodeType(obj)
      }
  }

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

  def jsonWritesGithubOwnerType(obj: io.flow.github.v0.models.OwnerType) = {
    play.api.libs.json.JsString(obj.toString)
  }

  def jsObjectOwnerType(obj: io.flow.github.v0.models.OwnerType) = {
    play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
  }

  implicit def jsonWritesGithubOwnerType: play.api.libs.json.Writes[OwnerType] = {
    (obj: io.flow.github.v0.models.OwnerType) =>
      {
        io.flow.github.v0.models.json.jsonWritesGithubOwnerType(obj)
      }
  }

  implicit val jsonReadsGithubVisibility: play.api.libs.json.Reads[io.flow.github.v0.models.Visibility] =
    new play.api.libs.json.Reads[io.flow.github.v0.models.Visibility] {
      def reads(js: play.api.libs.json.JsValue): play.api.libs.json.JsResult[io.flow.github.v0.models.Visibility] = {
        js match {
          case v: play.api.libs.json.JsString =>
            play.api.libs.json.JsSuccess(io.flow.github.v0.models.Visibility(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) =>
                play.api.libs.json.JsSuccess(io.flow.github.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.flow.github.v0.models.Visibility(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

  def jsonWritesGithubVisibility(obj: io.flow.github.v0.models.Visibility) = {
    play.api.libs.json.JsString(obj.toString)
  }

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

  implicit def jsonWritesGithubVisibility: play.api.libs.json.Writes[Visibility] = {
    (obj: io.flow.github.v0.models.Visibility) =>
      {
        io.flow.github.v0.models.json.jsonWritesGithubVisibility(obj)
      }
  }
  implicit def jsonReadsGithubBlob: play.api.libs.json.Reads[io.flow.github.v0.models.Blob] = {
    for {
      content <- (__ \ "content").read[String]
      encoding <- (__ \ "encoding").read[io.flow.github.v0.models.Encoding]
      url <- (__ \ "url").read[String]
      sha <- (__ \ "sha").read[String]
      size <- (__ \ "size").read[Long]
    } yield Blob(content, encoding, url, sha, size)
  }

  def jsObjectBlob(obj: io.flow.github.v0.models.Blob): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "content" -> play.api.libs.json.JsString(obj.content),
      "encoding" -> play.api.libs.json.JsString(obj.encoding.toString),
      "url" -> play.api.libs.json.JsString(obj.url),
      "sha" -> play.api.libs.json.JsString(obj.sha),
      "size" -> play.api.libs.json.JsNumber(obj.size)
    )
  }

  implicit def jsonWritesGithubBlob: play.api.libs.json.Writes[Blob] = { (obj: io.flow.github.v0.models.Blob) =>
    {
      io.flow.github.v0.models.json.jsObjectBlob(obj)
    }
  }

  implicit def jsonReadsGithubBlobCreated: play.api.libs.json.Reads[io.flow.github.v0.models.BlobCreated] = {
    for {
      url <- (__ \ "url").read[String]
      sha <- (__ \ "sha").read[String]
    } yield BlobCreated(url, sha)
  }

  def jsObjectBlobCreated(obj: io.flow.github.v0.models.BlobCreated): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "url" -> play.api.libs.json.JsString(obj.url),
      "sha" -> play.api.libs.json.JsString(obj.sha)
    )
  }

  implicit def jsonWritesGithubBlobCreated: play.api.libs.json.Writes[BlobCreated] = {
    (obj: io.flow.github.v0.models.BlobCreated) =>
      {
        io.flow.github.v0.models.json.jsObjectBlobCreated(obj)
      }
  }

  implicit def jsonReadsGithubBlobForm: play.api.libs.json.Reads[io.flow.github.v0.models.BlobForm] = {
    for {
      content <- (__ \ "content").read[String]
      encoding <- (__ \ "encoding").read[io.flow.github.v0.models.Encoding]
    } yield BlobForm(content, encoding)
  }

  def jsObjectBlobForm(obj: io.flow.github.v0.models.BlobForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "content" -> play.api.libs.json.JsString(obj.content),
      "encoding" -> play.api.libs.json.JsString(obj.encoding.toString)
    )
  }

  implicit def jsonWritesGithubBlobForm: play.api.libs.json.Writes[BlobForm] = {
    (obj: io.flow.github.v0.models.BlobForm) =>
      {
        io.flow.github.v0.models.json.jsObjectBlobForm(obj)
      }
  }

  implicit def jsonReadsGithubCommit: play.api.libs.json.Reads[io.flow.github.v0.models.Commit] = {
    for {
      sha <- (__ \ "sha").read[String]
      url <- (__ \ "url").read[String]
      htmlUrl <- (__ \ "html_url").read[String]
      author <- (__ \ "author").read[io.flow.github.v0.models.Person]
      committer <- (__ \ "committer").read[io.flow.github.v0.models.Person]
      tree <- (__ \ "tree").read[io.flow.github.v0.models.TreeSummary]
      message <- (__ \ "message").read[String]
      parents <- (__ \ "parents").read[Seq[io.flow.github.v0.models.CommitSummary]]
    } yield Commit(sha, url, htmlUrl, author, committer, tree, message, parents)
  }

  def jsObjectCommit(obj: io.flow.github.v0.models.Commit): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "sha" -> play.api.libs.json.JsString(obj.sha),
      "url" -> play.api.libs.json.JsString(obj.url),
      "html_url" -> play.api.libs.json.JsString(obj.htmlUrl),
      "author" -> io.flow.github.v0.models.json.jsObjectPerson(obj.author),
      "committer" -> io.flow.github.v0.models.json.jsObjectPerson(obj.committer),
      "tree" -> io.flow.github.v0.models.json.jsObjectTreeSummary(obj.tree),
      "message" -> play.api.libs.json.JsString(obj.message),
      "parents" -> play.api.libs.json.Json.toJson(obj.parents)
    )
  }

  implicit def jsonWritesGithubCommit: play.api.libs.json.Writes[Commit] = { (obj: io.flow.github.v0.models.Commit) =>
    {
      io.flow.github.v0.models.json.jsObjectCommit(obj)
    }
  }

  implicit def jsonReadsGithubCommitForm: play.api.libs.json.Reads[io.flow.github.v0.models.CommitForm] = {
    for {
      message <- (__ \ "message").read[String]
      tree <- (__ \ "tree").read[String]
      parents <- (__ \ "parents").read[Seq[String]]
      author <- (__ \ "author").read[io.flow.github.v0.models.Person]
      committer <- (__ \ "committer").read[io.flow.github.v0.models.Person]
    } yield CommitForm(message, tree, parents, author, committer)
  }

  def jsObjectCommitForm(obj: io.flow.github.v0.models.CommitForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "message" -> play.api.libs.json.JsString(obj.message),
      "tree" -> play.api.libs.json.JsString(obj.tree),
      "parents" -> play.api.libs.json.Json.toJson(obj.parents),
      "author" -> io.flow.github.v0.models.json.jsObjectPerson(obj.author),
      "committer" -> io.flow.github.v0.models.json.jsObjectPerson(obj.committer)
    )
  }

  implicit def jsonWritesGithubCommitForm: play.api.libs.json.Writes[CommitForm] = {
    (obj: io.flow.github.v0.models.CommitForm) =>
      {
        io.flow.github.v0.models.json.jsObjectCommitForm(obj)
      }
  }

  implicit def jsonReadsGithubCommitResponse: play.api.libs.json.Reads[io.flow.github.v0.models.CommitResponse] = {
    for {
      sha <- (__ \ "sha").read[String]
      url <- (__ \ "url").read[String]
      author <- (__ \ "author").read[io.flow.github.v0.models.Person]
      committer <- (__ \ "committer").read[io.flow.github.v0.models.Person]
      message <- (__ \ "message").read[String]
      tree <- (__ \ "tree").read[io.flow.github.v0.models.TreeSummary]
      parents <- (__ \ "parents").read[Seq[io.flow.github.v0.models.TreeSummary]]
    } yield CommitResponse(sha, url, author, committer, message, tree, parents)
  }

  def jsObjectCommitResponse(obj: io.flow.github.v0.models.CommitResponse): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "sha" -> play.api.libs.json.JsString(obj.sha),
      "url" -> play.api.libs.json.JsString(obj.url),
      "author" -> io.flow.github.v0.models.json.jsObjectPerson(obj.author),
      "committer" -> io.flow.github.v0.models.json.jsObjectPerson(obj.committer),
      "message" -> play.api.libs.json.JsString(obj.message),
      "tree" -> io.flow.github.v0.models.json.jsObjectTreeSummary(obj.tree),
      "parents" -> play.api.libs.json.Json.toJson(obj.parents)
    )
  }

  implicit def jsonWritesGithubCommitResponse: play.api.libs.json.Writes[CommitResponse] = {
    (obj: io.flow.github.v0.models.CommitResponse) =>
      {
        io.flow.github.v0.models.json.jsObjectCommitResponse(obj)
      }
  }

  implicit def jsonReadsGithubCommitSummary: play.api.libs.json.Reads[io.flow.github.v0.models.CommitSummary] = {
    for {
      sha <- (__ \ "sha").read[String]
      url <- (__ \ "url").read[String]
    } yield CommitSummary(sha, url)
  }

  def jsObjectCommitSummary(obj: io.flow.github.v0.models.CommitSummary): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "sha" -> play.api.libs.json.JsString(obj.sha),
      "url" -> play.api.libs.json.JsString(obj.url)
    )
  }

  implicit def jsonWritesGithubCommitSummary: play.api.libs.json.Writes[CommitSummary] = {
    (obj: io.flow.github.v0.models.CommitSummary) =>
      {
        io.flow.github.v0.models.json.jsObjectCommitSummary(obj)
      }
  }

  implicit def jsonReadsGithubContents: play.api.libs.json.Reads[io.flow.github.v0.models.Contents] = {
    for {
      `type` <- (__ \ "type").read[io.flow.github.v0.models.ContentsType]
      encoding <- (__ \ "encoding").read[io.flow.github.v0.models.Encoding]
      size <- (__ \ "size").read[Long]
      name <- (__ \ "name").read[String]
      path <- (__ \ "path").read[String]
      content <- (__ \ "content").readNullable[String]
      sha <- (__ \ "sha").read[String]
      url <- (__ \ "url").read[String]
      gitUrl <- (__ \ "git_url").read[String]
      htmlUrl <- (__ \ "html_url").read[String]
      downloadUrl <- (__ \ "download_url").read[String]
    } yield Contents(`type`, encoding, size, name, path, content, sha, url, gitUrl, htmlUrl, downloadUrl)
  }

  def jsObjectContents(obj: io.flow.github.v0.models.Contents): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "type" -> play.api.libs.json.JsString(obj.`type`.toString),
      "encoding" -> play.api.libs.json.JsString(obj.encoding.toString),
      "size" -> play.api.libs.json.JsNumber(obj.size),
      "name" -> play.api.libs.json.JsString(obj.name),
      "path" -> play.api.libs.json.JsString(obj.path),
      "sha" -> play.api.libs.json.JsString(obj.sha),
      "url" -> play.api.libs.json.JsString(obj.url),
      "git_url" -> play.api.libs.json.JsString(obj.gitUrl),
      "html_url" -> play.api.libs.json.JsString(obj.htmlUrl),
      "download_url" -> play.api.libs.json.JsString(obj.downloadUrl)
    ) ++ (obj.content match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("content" -> play.api.libs.json.JsString(x))
    })
  }

  implicit def jsonWritesGithubContents: play.api.libs.json.Writes[Contents] = {
    (obj: io.flow.github.v0.models.Contents) =>
      {
        io.flow.github.v0.models.json.jsObjectContents(obj)
      }
  }

  implicit def jsonReadsGithubCreateTreeForm: play.api.libs.json.Reads[io.flow.github.v0.models.CreateTreeForm] = {
    for {
      baseTree <- (__ \ "base_tree").read[String]
      tree <- (__ \ "tree").read[Seq[io.flow.github.v0.models.TreeForm]]
    } yield CreateTreeForm(baseTree, tree)
  }

  def jsObjectCreateTreeForm(obj: io.flow.github.v0.models.CreateTreeForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "base_tree" -> play.api.libs.json.JsString(obj.baseTree),
      "tree" -> play.api.libs.json.Json.toJson(obj.tree)
    )
  }

  implicit def jsonWritesGithubCreateTreeForm: play.api.libs.json.Writes[CreateTreeForm] = {
    (obj: io.flow.github.v0.models.CreateTreeForm) =>
      {
        io.flow.github.v0.models.json.jsObjectCreateTreeForm(obj)
      }
  }

  implicit def jsonReadsGithubCreateTreeResponse
      : play.api.libs.json.Reads[io.flow.github.v0.models.CreateTreeResponse] = {
    for {
      sha <- (__ \ "sha").read[String]
      url <- (__ \ "url").read[String]
      treeResult <- (__ \ "tree_result").read[io.flow.github.v0.models.Tree]
    } yield CreateTreeResponse(sha, url, treeResult)
  }

  def jsObjectCreateTreeResponse(obj: io.flow.github.v0.models.CreateTreeResponse): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "sha" -> play.api.libs.json.JsString(obj.sha),
      "url" -> play.api.libs.json.JsString(obj.url),
      "tree_result" -> io.flow.github.v0.models.json.jsObjectTree(obj.treeResult)
    )
  }

  implicit def jsonWritesGithubCreateTreeResponse: play.api.libs.json.Writes[CreateTreeResponse] = {
    (obj: io.flow.github.v0.models.CreateTreeResponse) =>
      {
        io.flow.github.v0.models.json.jsObjectCreateTreeResponse(obj)
      }
  }

  implicit def jsonReadsGithubError: play.api.libs.json.Reads[io.flow.github.v0.models.Error] = {
    for {
      resource <- (__ \ "resource").read[String]
      field <- (__ \ "field").read[String]
      code <- (__ \ "code").read[String]
    } yield Error(resource, field, code)
  }

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

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

  implicit def jsonReadsGithubGithubObject: play.api.libs.json.Reads[io.flow.github.v0.models.GithubObject] = {
    for {
      `type` <- (__ \ "type").read[String]
      sha <- (__ \ "sha").read[String]
      url <- (__ \ "url").read[String]
    } yield GithubObject(`type`, sha, url)
  }

  def jsObjectGithubObject(obj: io.flow.github.v0.models.GithubObject): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "type" -> play.api.libs.json.JsString(obj.`type`),
      "sha" -> play.api.libs.json.JsString(obj.sha),
      "url" -> play.api.libs.json.JsString(obj.url)
    )
  }

  implicit def jsonWritesGithubGithubObject: play.api.libs.json.Writes[GithubObject] = {
    (obj: io.flow.github.v0.models.GithubObject) =>
      {
        io.flow.github.v0.models.json.jsObjectGithubObject(obj)
      }
  }

  implicit def jsonReadsGithubHook: play.api.libs.json.Reads[io.flow.github.v0.models.Hook] = {
    for {
      id <- (__ \ "id").read[Long]
      url <- (__ \ "url").read[String]
      testUrl <- (__ \ "test_url").read[String]
      pingUrl <- (__ \ "ping_url").read[String]
      name <- (__ \ "name").read[String]
      events <- (__ \ "events").read[Seq[io.flow.github.v0.models.HookEvent]]
      active <- (__ \ "active").read[Boolean]
      config <- (__ \ "config").read[io.flow.github.v0.models.HookConfig]
      updatedAt <- (__ \ "updated_at").read[_root_.java.time.OffsetDateTime]
      createdAt <- (__ \ "created_at").read[_root_.java.time.OffsetDateTime]
    } yield Hook(id, url, testUrl, pingUrl, name, events, active, config, updatedAt, createdAt)
  }

  def jsObjectHook(obj: io.flow.github.v0.models.Hook): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "id" -> play.api.libs.json.JsNumber(obj.id),
      "url" -> play.api.libs.json.JsString(obj.url),
      "test_url" -> play.api.libs.json.JsString(obj.testUrl),
      "ping_url" -> play.api.libs.json.JsString(obj.pingUrl),
      "name" -> play.api.libs.json.JsString(obj.name),
      "events" -> play.api.libs.json.Json.toJson(obj.events),
      "active" -> play.api.libs.json.JsBoolean(obj.active),
      "config" -> io.flow.github.v0.models.json.jsObjectHookConfig(obj.config),
      "updated_at" -> play.api.libs.json.JsString(obj.updatedAt.toString),
      "created_at" -> play.api.libs.json.JsString(obj.createdAt.toString)
    )
  }

  implicit def jsonWritesGithubHook: play.api.libs.json.Writes[Hook] = { (obj: io.flow.github.v0.models.Hook) =>
    {
      io.flow.github.v0.models.json.jsObjectHook(obj)
    }
  }

  implicit def jsonReadsGithubHookConfig: play.api.libs.json.Reads[io.flow.github.v0.models.HookConfig] = {
    for {
      url <- (__ \ "url").readNullable[String]
      contentType <- (__ \ "content_type").readNullable[String]
    } yield HookConfig(url, contentType)
  }

  def jsObjectHookConfig(obj: io.flow.github.v0.models.HookConfig): play.api.libs.json.JsObject = {
    (obj.url match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("url" -> play.api.libs.json.JsString(x))
    }) ++
      (obj.contentType match {
        case None    => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("content_type" -> play.api.libs.json.JsString(x))
      })
  }

  implicit def jsonWritesGithubHookConfig: play.api.libs.json.Writes[HookConfig] = {
    (obj: io.flow.github.v0.models.HookConfig) =>
      {
        io.flow.github.v0.models.json.jsObjectHookConfig(obj)
      }
  }

  implicit def jsonReadsGithubHookForm: play.api.libs.json.Reads[io.flow.github.v0.models.HookForm] = {
    for {
      name <- (__ \ "name").read[String]
      config <- (__ \ "config").read[io.flow.github.v0.models.HookConfig]
      events <- (__ \ "events").read[Seq[io.flow.github.v0.models.HookEvent]]
      active <- (__ \ "active").read[Boolean]
    } yield HookForm(name, config, events, active)
  }

  def jsObjectHookForm(obj: io.flow.github.v0.models.HookForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "name" -> play.api.libs.json.JsString(obj.name),
      "config" -> io.flow.github.v0.models.json.jsObjectHookConfig(obj.config),
      "events" -> play.api.libs.json.Json.toJson(obj.events),
      "active" -> play.api.libs.json.JsBoolean(obj.active)
    )
  }

  implicit def jsonWritesGithubHookForm: play.api.libs.json.Writes[HookForm] = {
    (obj: io.flow.github.v0.models.HookForm) =>
      {
        io.flow.github.v0.models.json.jsObjectHookForm(obj)
      }
  }

  implicit def jsonReadsGithubNode: play.api.libs.json.Reads[io.flow.github.v0.models.Node] = {
    for {
      path <- (__ \ "path").read[String]
      mode <- (__ \ "mode").read[String]
      `type` <- (__ \ "type").read[io.flow.github.v0.models.NodeType]
      size <- (__ \ "size").read[Long]
      sha <- (__ \ "sha").read[String]
      url <- (__ \ "url").read[String]
    } yield Node(path, mode, `type`, size, sha, url)
  }

  def jsObjectNode(obj: io.flow.github.v0.models.Node): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "path" -> play.api.libs.json.JsString(obj.path),
      "mode" -> play.api.libs.json.JsString(obj.mode),
      "type" -> play.api.libs.json.JsString(obj.`type`.toString),
      "size" -> play.api.libs.json.JsNumber(obj.size),
      "sha" -> play.api.libs.json.JsString(obj.sha),
      "url" -> play.api.libs.json.JsString(obj.url)
    )
  }

  implicit def jsonWritesGithubNode: play.api.libs.json.Writes[Node] = { (obj: io.flow.github.v0.models.Node) =>
    {
      io.flow.github.v0.models.json.jsObjectNode(obj)
    }
  }

  implicit def jsonReadsGithubNodeForm: play.api.libs.json.Reads[io.flow.github.v0.models.NodeForm] = {
    for {
      path <- (__ \ "path").read[String]
      mode <- (__ \ "mode").read[String]
      `type` <- (__ \ "type").read[io.flow.github.v0.models.NodeType]
      sha <- (__ \ "sha").read[String]
    } yield NodeForm(path, mode, `type`, sha)
  }

  def jsObjectNodeForm(obj: io.flow.github.v0.models.NodeForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "path" -> play.api.libs.json.JsString(obj.path),
      "mode" -> play.api.libs.json.JsString(obj.mode),
      "type" -> play.api.libs.json.JsString(obj.`type`.toString),
      "sha" -> play.api.libs.json.JsString(obj.sha)
    )
  }

  implicit def jsonWritesGithubNodeForm: play.api.libs.json.Writes[NodeForm] = {
    (obj: io.flow.github.v0.models.NodeForm) =>
      {
        io.flow.github.v0.models.json.jsObjectNodeForm(obj)
      }
  }

  implicit def jsonReadsGithubPerson: play.api.libs.json.Reads[io.flow.github.v0.models.Person] = {
    for {
      name <- (__ \ "name").read[String]
      email <- (__ \ "email").read[String]
      date <- (__ \ "date").read[_root_.java.time.OffsetDateTime]
    } yield Person(name, email, date)
  }

  def jsObjectPerson(obj: io.flow.github.v0.models.Person): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "name" -> play.api.libs.json.JsString(obj.name),
      "email" -> play.api.libs.json.JsString(obj.email),
      "date" -> play.api.libs.json.JsString(obj.date.toString)
    )
  }

  implicit def jsonWritesGithubPerson: play.api.libs.json.Writes[Person] = { (obj: io.flow.github.v0.models.Person) =>
    {
      io.flow.github.v0.models.json.jsObjectPerson(obj)
    }
  }

  implicit def jsonReadsGithubPullRequest: play.api.libs.json.Reads[io.flow.github.v0.models.PullRequest] = {
    for {
      id <- (__ \ "id").read[Long]
      url <- (__ \ "url").read[String]
      number <- (__ \ "number").read[Long]
      htmlUrl <- (__ \ "html_url").read[String]
      head <- (__ \ "head").read[io.flow.github.v0.models.PullRequestHead]
    } yield PullRequest(id, url, number, htmlUrl, head)
  }

  def jsObjectPullRequest(obj: io.flow.github.v0.models.PullRequest): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "id" -> play.api.libs.json.JsNumber(obj.id),
      "url" -> play.api.libs.json.JsString(obj.url),
      "number" -> play.api.libs.json.JsNumber(obj.number),
      "html_url" -> play.api.libs.json.JsString(obj.htmlUrl),
      "head" -> io.flow.github.v0.models.json.jsObjectPullRequestHead(obj.head)
    )
  }

  implicit def jsonWritesGithubPullRequest: play.api.libs.json.Writes[PullRequest] = {
    (obj: io.flow.github.v0.models.PullRequest) =>
      {
        io.flow.github.v0.models.json.jsObjectPullRequest(obj)
      }
  }

  implicit def jsonReadsGithubPullRequestForm: play.api.libs.json.Reads[io.flow.github.v0.models.PullRequestForm] = {
    for {
      title <- (__ \ "title").read[String]
      head <- (__ \ "head").read[String]
      base <- (__ \ "base").read[String]
      body <- (__ \ "body").readNullable[String]
    } yield PullRequestForm(title, head, base, body)
  }

  def jsObjectPullRequestForm(obj: io.flow.github.v0.models.PullRequestForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "title" -> play.api.libs.json.JsString(obj.title),
      "head" -> play.api.libs.json.JsString(obj.head),
      "base" -> play.api.libs.json.JsString(obj.base)
    ) ++ (obj.body match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("body" -> play.api.libs.json.JsString(x))
    })
  }

  implicit def jsonWritesGithubPullRequestForm: play.api.libs.json.Writes[PullRequestForm] = {
    (obj: io.flow.github.v0.models.PullRequestForm) =>
      {
        io.flow.github.v0.models.json.jsObjectPullRequestForm(obj)
      }
  }

  implicit def jsonReadsGithubPullRequestHead: play.api.libs.json.Reads[io.flow.github.v0.models.PullRequestHead] = {
    (__ \ "ref").read[String].map { x =>
      PullRequestHead(ref = x)
    }
  }

  def jsObjectPullRequestHead(obj: io.flow.github.v0.models.PullRequestHead): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "ref" -> play.api.libs.json.JsString(obj.ref)
    )
  }

  implicit def jsonWritesGithubPullRequestHead: play.api.libs.json.Writes[PullRequestHead] = {
    (obj: io.flow.github.v0.models.PullRequestHead) =>
      {
        io.flow.github.v0.models.json.jsObjectPullRequestHead(obj)
      }
  }

  implicit def jsonReadsGithubRef: play.api.libs.json.Reads[io.flow.github.v0.models.Ref] = {
    for {
      ref <- (__ \ "ref").read[String]
      url <- (__ \ "url").read[String]
      `object` <- (__ \ "object").read[io.flow.github.v0.models.GithubObject]
    } yield Ref(ref, url, `object`)
  }

  def jsObjectRef(obj: io.flow.github.v0.models.Ref): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "ref" -> play.api.libs.json.JsString(obj.ref),
      "url" -> play.api.libs.json.JsString(obj.url),
      "object" -> io.flow.github.v0.models.json.jsObjectGithubObject(obj.`object`)
    )
  }

  implicit def jsonWritesGithubRef: play.api.libs.json.Writes[Ref] = { (obj: io.flow.github.v0.models.Ref) =>
    {
      io.flow.github.v0.models.json.jsObjectRef(obj)
    }
  }

  implicit def jsonReadsGithubRefForm: play.api.libs.json.Reads[io.flow.github.v0.models.RefForm] = {
    for {
      ref <- (__ \ "ref").read[String]
      sha <- (__ \ "sha").read[String]
    } yield RefForm(ref, sha)
  }

  def jsObjectRefForm(obj: io.flow.github.v0.models.RefForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "ref" -> play.api.libs.json.JsString(obj.ref),
      "sha" -> play.api.libs.json.JsString(obj.sha)
    )
  }

  implicit def jsonWritesGithubRefForm: play.api.libs.json.Writes[RefForm] = {
    (obj: io.flow.github.v0.models.RefForm) =>
      {
        io.flow.github.v0.models.json.jsObjectRefForm(obj)
      }
  }

  implicit def jsonReadsGithubRefUpdateForm: play.api.libs.json.Reads[io.flow.github.v0.models.RefUpdateForm] = {
    (__ \ "sha").read[String].map { x =>
      RefUpdateForm(sha = x)
    }
  }

  def jsObjectRefUpdateForm(obj: io.flow.github.v0.models.RefUpdateForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "sha" -> play.api.libs.json.JsString(obj.sha)
    )
  }

  implicit def jsonWritesGithubRefUpdateForm: play.api.libs.json.Writes[RefUpdateForm] = {
    (obj: io.flow.github.v0.models.RefUpdateForm) =>
      {
        io.flow.github.v0.models.json.jsObjectRefUpdateForm(obj)
      }
  }

  implicit def jsonReadsGithubRepository: play.api.libs.json.Reads[io.flow.github.v0.models.Repository] = {
    for {
      id <- (__ \ "id").read[Long]
      owner <- (__ \ "owner").read[io.flow.github.v0.models.User]
      name <- (__ \ "name").read[String]
      fullName <- (__ \ "full_name").read[String]
      `private` <- (__ \ "private").read[Boolean]
      description <- (__ \ "description").readNullable[String]
      url <- (__ \ "url").read[String]
      htmlUrl <- (__ \ "html_url").read[String]
      defaultBranch <- (__ \ "default_branch").read[String]
    } yield Repository(id, owner, name, fullName, `private`, description, url, htmlUrl, defaultBranch)
  }

  def jsObjectRepository(obj: io.flow.github.v0.models.Repository): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "id" -> play.api.libs.json.JsNumber(obj.id),
      "owner" -> io.flow.github.v0.models.json.jsObjectUser(obj.owner),
      "name" -> play.api.libs.json.JsString(obj.name),
      "full_name" -> play.api.libs.json.JsString(obj.fullName),
      "private" -> play.api.libs.json.JsBoolean(obj.`private`),
      "url" -> play.api.libs.json.JsString(obj.url),
      "html_url" -> play.api.libs.json.JsString(obj.htmlUrl),
      "default_branch" -> play.api.libs.json.JsString(obj.defaultBranch)
    ) ++ (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 jsonWritesGithubRepository: play.api.libs.json.Writes[Repository] = {
    (obj: io.flow.github.v0.models.Repository) =>
      {
        io.flow.github.v0.models.json.jsObjectRepository(obj)
      }
  }

  implicit def jsonReadsGithubTag: play.api.libs.json.Reads[io.flow.github.v0.models.Tag] = {
    for {
      tag <- (__ \ "tag").read[String]
      sha <- (__ \ "sha").read[String]
      url <- (__ \ "url").read[String]
      message <- (__ \ "message").read[String]
      tagger <- (__ \ "tagger").read[io.flow.github.v0.models.Tagger]
      `object` <- (__ \ "object").read[io.flow.github.v0.models.GithubObject]
    } yield Tag(tag, sha, url, message, tagger, `object`)
  }

  def jsObjectTag(obj: io.flow.github.v0.models.Tag): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "tag" -> play.api.libs.json.JsString(obj.tag),
      "sha" -> play.api.libs.json.JsString(obj.sha),
      "url" -> play.api.libs.json.JsString(obj.url),
      "message" -> play.api.libs.json.JsString(obj.message),
      "tagger" -> io.flow.github.v0.models.json.jsObjectTagger(obj.tagger),
      "object" -> io.flow.github.v0.models.json.jsObjectGithubObject(obj.`object`)
    )
  }

  implicit def jsonWritesGithubTag: play.api.libs.json.Writes[Tag] = { (obj: io.flow.github.v0.models.Tag) =>
    {
      io.flow.github.v0.models.json.jsObjectTag(obj)
    }
  }

  implicit def jsonReadsGithubTagForm: play.api.libs.json.Reads[io.flow.github.v0.models.TagForm] = {
    for {
      tag <- (__ \ "tag").read[String]
      message <- (__ \ "message").read[String]
      `object` <- (__ \ "object").read[String]
      `type` <- (__ \ "type").read[String]
      tagger <- (__ \ "tagger").read[io.flow.github.v0.models.Tagger]
    } yield TagForm(tag, message, `object`, `type`, tagger)
  }

  def jsObjectTagForm(obj: io.flow.github.v0.models.TagForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "tag" -> play.api.libs.json.JsString(obj.tag),
      "message" -> play.api.libs.json.JsString(obj.message),
      "object" -> play.api.libs.json.JsString(obj.`object`),
      "type" -> play.api.libs.json.JsString(obj.`type`),
      "tagger" -> io.flow.github.v0.models.json.jsObjectTagger(obj.tagger)
    )
  }

  implicit def jsonWritesGithubTagForm: play.api.libs.json.Writes[TagForm] = {
    (obj: io.flow.github.v0.models.TagForm) =>
      {
        io.flow.github.v0.models.json.jsObjectTagForm(obj)
      }
  }

  implicit def jsonReadsGithubTagSummary: play.api.libs.json.Reads[io.flow.github.v0.models.TagSummary] = {
    for {
      name <- (__ \ "name").read[String]
      commit <- (__ \ "commit").read[io.flow.github.v0.models.CommitSummary]
    } yield TagSummary(name, commit)
  }

  def jsObjectTagSummary(obj: io.flow.github.v0.models.TagSummary): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "name" -> play.api.libs.json.JsString(obj.name),
      "commit" -> io.flow.github.v0.models.json.jsObjectCommitSummary(obj.commit)
    )
  }

  implicit def jsonWritesGithubTagSummary: play.api.libs.json.Writes[TagSummary] = {
    (obj: io.flow.github.v0.models.TagSummary) =>
      {
        io.flow.github.v0.models.json.jsObjectTagSummary(obj)
      }
  }

  implicit def jsonReadsGithubTagger: play.api.libs.json.Reads[io.flow.github.v0.models.Tagger] = {
    for {
      name <- (__ \ "name").read[String]
      email <- (__ \ "email").read[String]
      date <- (__ \ "date").read[_root_.java.time.OffsetDateTime]
    } yield Tagger(name, email, date)
  }

  def jsObjectTagger(obj: io.flow.github.v0.models.Tagger): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "name" -> play.api.libs.json.JsString(obj.name),
      "email" -> play.api.libs.json.JsString(obj.email),
      "date" -> play.api.libs.json.JsString(obj.date.toString)
    )
  }

  implicit def jsonWritesGithubTagger: play.api.libs.json.Writes[Tagger] = { (obj: io.flow.github.v0.models.Tagger) =>
    {
      io.flow.github.v0.models.json.jsObjectTagger(obj)
    }
  }

  implicit def jsonReadsGithubTree: play.api.libs.json.Reads[io.flow.github.v0.models.Tree] = {
    for {
      sha <- (__ \ "sha").read[String]
      url <- (__ \ "url").read[String]
      truncated <- (__ \ "truncated").read[Boolean]
      tree <- (__ \ "tree").read[Seq[io.flow.github.v0.models.Node]]
    } yield Tree(sha, url, truncated, tree)
  }

  def jsObjectTree(obj: io.flow.github.v0.models.Tree): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "sha" -> play.api.libs.json.JsString(obj.sha),
      "url" -> play.api.libs.json.JsString(obj.url),
      "truncated" -> play.api.libs.json.JsBoolean(obj.truncated),
      "tree" -> play.api.libs.json.Json.toJson(obj.tree)
    )
  }

  implicit def jsonWritesGithubTree: play.api.libs.json.Writes[Tree] = { (obj: io.flow.github.v0.models.Tree) =>
    {
      io.flow.github.v0.models.json.jsObjectTree(obj)
    }
  }

  implicit def jsonReadsGithubTreeForm: play.api.libs.json.Reads[io.flow.github.v0.models.TreeForm] = {
    for {
      path <- (__ \ "path").read[String]
      mode <- (__ \ "mode").read[String]
      `type` <- (__ \ "type").read[io.flow.github.v0.models.NodeType]
      sha <- (__ \ "sha").readNullable[String]
      content <- (__ \ "content").readNullable[String]
    } yield TreeForm(path, mode, `type`, sha, content)
  }

  def jsObjectTreeForm(obj: io.flow.github.v0.models.TreeForm): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "path" -> play.api.libs.json.JsString(obj.path),
      "mode" -> play.api.libs.json.JsString(obj.mode),
      "type" -> play.api.libs.json.JsString(obj.`type`.toString)
    ) ++ (obj.sha match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("sha" -> play.api.libs.json.JsString(x))
    }) ++
      (obj.content match {
        case None    => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("content" -> play.api.libs.json.JsString(x))
      })
  }

  implicit def jsonWritesGithubTreeForm: play.api.libs.json.Writes[TreeForm] = {
    (obj: io.flow.github.v0.models.TreeForm) =>
      {
        io.flow.github.v0.models.json.jsObjectTreeForm(obj)
      }
  }

  implicit def jsonReadsGithubTreeResult: play.api.libs.json.Reads[io.flow.github.v0.models.TreeResult] = {
    for {
      path <- (__ \ "path").read[String]
      mode <- (__ \ "mode").read[String]
      `type` <- (__ \ "type").read[io.flow.github.v0.models.NodeType]
      size <- (__ \ "size").read[Long]
      sha <- (__ \ "sha").read[String]
      url <- (__ \ "url").read[String]
    } yield TreeResult(path, mode, `type`, size, sha, url)
  }

  def jsObjectTreeResult(obj: io.flow.github.v0.models.TreeResult): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "path" -> play.api.libs.json.JsString(obj.path),
      "mode" -> play.api.libs.json.JsString(obj.mode),
      "type" -> play.api.libs.json.JsString(obj.`type`.toString),
      "size" -> play.api.libs.json.JsNumber(obj.size),
      "sha" -> play.api.libs.json.JsString(obj.sha),
      "url" -> play.api.libs.json.JsString(obj.url)
    )
  }

  implicit def jsonWritesGithubTreeResult: play.api.libs.json.Writes[TreeResult] = {
    (obj: io.flow.github.v0.models.TreeResult) =>
      {
        io.flow.github.v0.models.json.jsObjectTreeResult(obj)
      }
  }

  implicit def jsonReadsGithubTreeSummary: play.api.libs.json.Reads[io.flow.github.v0.models.TreeSummary] = {
    for {
      url <- (__ \ "url").read[String]
      sha <- (__ \ "sha").read[String]
    } yield TreeSummary(url, sha)
  }

  def jsObjectTreeSummary(obj: io.flow.github.v0.models.TreeSummary): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "url" -> play.api.libs.json.JsString(obj.url),
      "sha" -> play.api.libs.json.JsString(obj.sha)
    )
  }

  implicit def jsonWritesGithubTreeSummary: play.api.libs.json.Writes[TreeSummary] = {
    (obj: io.flow.github.v0.models.TreeSummary) =>
      {
        io.flow.github.v0.models.json.jsObjectTreeSummary(obj)
      }
  }

  implicit def jsonReadsGithubUnprocessableEntity
      : play.api.libs.json.Reads[io.flow.github.v0.models.UnprocessableEntity] = {
    for {
      message <- (__ \ "message").read[String]
      errors <- (__ \ "errors").readNullable[Seq[io.flow.github.v0.models.Error]]
    } yield UnprocessableEntity(message, errors)
  }

  def jsObjectUnprocessableEntity(obj: io.flow.github.v0.models.UnprocessableEntity): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "message" -> play.api.libs.json.JsString(obj.message)
    ) ++ (obj.errors match {
      case None    => play.api.libs.json.Json.obj()
      case Some(x) => play.api.libs.json.Json.obj("errors" -> play.api.libs.json.Json.toJson(x))
    })
  }

  implicit def jsonWritesGithubUnprocessableEntity: play.api.libs.json.Writes[UnprocessableEntity] = {
    (obj: io.flow.github.v0.models.UnprocessableEntity) =>
      {
        io.flow.github.v0.models.json.jsObjectUnprocessableEntity(obj)
      }
  }

  implicit def jsonReadsGithubUser: play.api.libs.json.Reads[io.flow.github.v0.models.User] = {
    for {
      id <- (__ \ "id").read[Long]
      login <- (__ \ "login").read[String]
      name <- (__ \ "name").readNullable[String]
      email <- (__ \ "email").readNullable[String]
      avatarUrl <- (__ \ "avatar_url").readNullable[String]
      gravatarId <- (__ \ "gravatar_id").readNullable[String]
      url <- (__ \ "url").read[String]
      htmlUrl <- (__ \ "html_url").read[String]
      `type` <- (__ \ "type").read[io.flow.github.v0.models.OwnerType]
    } yield User(id, login, name, email, avatarUrl, gravatarId, url, htmlUrl, `type`)
  }

  def jsObjectUser(obj: io.flow.github.v0.models.User): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "id" -> play.api.libs.json.JsNumber(obj.id),
      "login" -> play.api.libs.json.JsString(obj.login),
      "url" -> play.api.libs.json.JsString(obj.url),
      "html_url" -> play.api.libs.json.JsString(obj.htmlUrl),
      "type" -> play.api.libs.json.JsString(obj.`type`.toString)
    ) ++ (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))
    }) ++
      (obj.email match {
        case None    => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("email" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.avatarUrl match {
        case None    => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("avatar_url" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.gravatarId match {
        case None    => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("gravatar_id" -> play.api.libs.json.JsString(x))
      })
  }

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

  implicit def jsonReadsGithubUserEmail: play.api.libs.json.Reads[io.flow.github.v0.models.UserEmail] = {
    for {
      email <- (__ \ "email").read[String]
      verified <- (__ \ "verified").read[Boolean]
      primary <- (__ \ "primary").read[Boolean]
    } yield UserEmail(email, verified, primary)
  }

  def jsObjectUserEmail(obj: io.flow.github.v0.models.UserEmail): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "email" -> play.api.libs.json.JsString(obj.email),
      "verified" -> play.api.libs.json.JsBoolean(obj.verified),
      "primary" -> play.api.libs.json.JsBoolean(obj.primary)
    )
  }

  implicit def jsonWritesGithubUserEmail: play.api.libs.json.Writes[UserEmail] = {
    (obj: io.flow.github.v0.models.UserEmail) =>
      {
        io.flow.github.v0.models.json.jsObjectUserEmail(obj)
      }
  }

  implicit def jsonReadsGithubUserOrg: play.api.libs.json.Reads[io.flow.github.v0.models.UserOrg] = {
    (__ \ "login").read[String].map { x =>
      UserOrg(login = x)
    }
  }

  def jsObjectUserOrg(obj: io.flow.github.v0.models.UserOrg): play.api.libs.json.JsObject = {
    play.api.libs.json.Json.obj(
      "login" -> play.api.libs.json.JsString(obj.login)
    )
  }

  implicit def jsonWritesGithubUserOrg: play.api.libs.json.Writes[UserOrg] = {
    (obj: io.flow.github.v0.models.UserOrg) =>
      {
        io.flow.github.v0.models.json.jsObjectUserOrg(obj)
      }
  }

}