/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.2.16
 * apibuilder 0.15.11 app.apibuilder.io/flow/github/0.2.16/http4s_0_15
 */
package io.flow.github.v0.server

import org.http4s.dsl._

import io.flow.github.v0.models.json._

private[server] object Matchers {

  implicit lazy val queryParamDecodeBigDecimal: org.http4s.QueryParamDecoder[BigDecimal] =
    org.http4s.QueryParamDecoder.fromUnsafeCast[BigDecimal](p => BigDecimal(p.value))("BigDecimal")

  implicit lazy val queryParamDecodeInstant: org.http4s.QueryParamDecoder[_root_.java.time.Instant] =
    org.http4s.QueryParamDecoder.fromUnsafeCast[_root_.java.time.Instant](p => _root_.java.time.OffsetDateTime.parse(p.value).toInstant)("_root_.java.time.Instant")

  implicit lazy val queryParamDecodeLocalDate: org.http4s.QueryParamDecoder[_root_.java.time.LocalDate] =
    org.http4s.QueryParamDecoder.fromUnsafeCast[_root_.java.time.LocalDate](p => _root_.java.time.LocalDate.parse(p.value))("_root_.java.time.LocalDate")

  implicit lazy val queryParamDecodeUUID: org.http4s.QueryParamDecoder[_root_.java.util.UUID] =
    org.http4s.QueryParamDecoder.fromUnsafeCast[_root_.java.util.UUID](p => _root_.java.util.UUID.fromString(p.value))("_root_.java.util.UUID")

  implicit lazy val visibilityQueryParamDecoder: org.http4s.QueryParamDecoder[io.flow.github.v0.models.Visibility] =
    org.http4s.QueryParamDecoder.fromUnsafeCast[io.flow.github.v0.models.Visibility](p => io.flow.github.v0.models.Visibility.fromString(p.value).get)("io.flow.github.v0.models.Visibility")

  object ApiVersion {
    val ApiVersionMajor = {
      "X-Apidoc-Version-Major".ci
    }

    def apply(req: org.http4s.Message): Boolean = req.headers.get(ApiVersionMajor) match {
      case Some(v) if v.value == "0" => true
      case _ => false
    }
  }

  object LongVal {
    def unapply(s: String): Option[Long] = scala.util.Try(s.toLong).toOption
  }

  object AffiliationOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("affiliation")

  object DirectionStringDefAscMatcher extends QueryParamDecoderMatcher[String]("direction") {
    override def unapply(params: Map[String, Seq[String]]) = super.unapply(params).orElse(Some("asc"))
  }

  object PageLongDef1Matcher extends QueryParamDecoderMatcher[Long]("page") {
    override def unapply(params: Map[String, Seq[String]]) = super.unapply(params).orElse(Some(1L))
  }

  object PerPageLongDef30Matcher extends QueryParamDecoderMatcher[Long]("per_page") {
    override def unapply(params: Map[String, Seq[String]]) = super.unapply(params).orElse(Some(30L))
  }

  object RefStringDefMasterMatcher extends QueryParamDecoderMatcher[String]("ref") {
    override def unapply(params: Map[String, Seq[String]]) = super.unapply(params).orElse(Some("master"))
  }

  object SortStringDefFullNameMatcher extends QueryParamDecoderMatcher[String]("sort") {
    override def unapply(params: Map[String, Seq[String]]) = super.unapply(params).orElse(Some("full_name"))
  }

  object TypeOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("type")

  object TypeStringDefAllMatcher extends QueryParamDecoderMatcher[String]("type") {
    override def unapply(params: Map[String, Seq[String]]) = super.unapply(params).orElse(Some("all"))
  }

  object TypeStringDefOwnerMatcher extends QueryParamDecoderMatcher[String]("type") {
    override def unapply(params: Map[String, Seq[String]]) = super.unapply(params).orElse(Some("owner"))
  }

  object VisibilityVisibilityDefAllMatcher extends QueryParamDecoderMatcher[io.flow.github.v0.models.Visibility]("visibility") {
    override def unapply(params: Map[String, Seq[String]]) = super.unapply(params).orElse(Some(io.flow.github.v0.models.Visibility.All))
  }
}

trait BlobRoutes {

  import Matchers._

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A]) = org.http4s.circe.jsonOf[A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[A]

  sealed trait GetByShaResponse

  object GetByShaResponse {
    case class HTTP200(value: io.flow.github.v0.models.Blob, headers: Seq[org.http4s.Header] = Nil) extends GetByShaResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends GetByShaResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetByShaResponse
  }

  def getBySha(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    sha: String
  ): scalaz.concurrent.Task[GetByShaResponse]

  sealed trait PostResponse

  object PostResponse {
    case class HTTP201(value: io.flow.github.v0.models.BlobCreated, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP422(value: io.flow.github.v0.models.UnprocessableEntity, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends PostResponse
  }

  def post(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    body: => org.http4s.DecodeResult[io.flow.github.v0.models.BlobForm]
  ): scalaz.concurrent.Task[PostResponse]

  def apiVersionMatch(req: org.http4s.Message): Boolean = ApiVersion(req)

  def service() = org.http4s.HttpService {
    case _req @ GET -> Root / "repos" / owner / repo / "git" / "blobs" / sha if apiVersionMatch(_req) =>
      getBySha(_req, owner, repo, sha).flatMap {
        case GetByShaResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetByShaResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case GetByShaResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "repos" / owner / repo / "git" / "blobs" / sha if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "repos" / owner / repo / "git" / "blobs" if apiVersionMatch(_req) =>
      post(_req, owner, repo, _req.attemptAs[io.flow.github.v0.models.BlobForm]).flatMap {
        case PostResponse.HTTP201(value, headers) => Created(value).putHeaders(headers: _*)
        case PostResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value).putHeaders(headers: _*)
        case PostResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "repos" / owner / repo / "git" / "blobs" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait CommitRoutes {

  import Matchers._

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A]) = org.http4s.circe.jsonOf[A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[A]

  sealed trait GetByShaResponse

  object GetByShaResponse {
    case class HTTP200(value: io.flow.github.v0.models.Commit, headers: Seq[org.http4s.Header] = Nil) extends GetByShaResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends GetByShaResponse
    case class HTTP422(value: io.flow.github.v0.models.UnprocessableEntity, headers: Seq[org.http4s.Header] = Nil) extends GetByShaResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetByShaResponse
  }

  def getBySha(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    sha: String
  ): scalaz.concurrent.Task[GetByShaResponse]

  sealed trait PostResponse

  object PostResponse {
    case class HTTP201(value: io.flow.github.v0.models.CommitResponse, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP422(value: io.flow.github.v0.models.UnprocessableEntity, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends PostResponse
  }

  def post(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    body: => org.http4s.DecodeResult[io.flow.github.v0.models.CommitForm]
  ): scalaz.concurrent.Task[PostResponse]

  def apiVersionMatch(req: org.http4s.Message): Boolean = ApiVersion(req)

  def service() = org.http4s.HttpService {
    case _req @ GET -> Root / "repos" / owner / repo / "git" / "commits" / sha if apiVersionMatch(_req) =>
      getBySha(_req, owner, repo, sha).flatMap {
        case GetByShaResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetByShaResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case GetByShaResponse.HTTP422(value, headers) => UnprocessableEntity(value).putHeaders(headers: _*)
        case GetByShaResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "repos" / owner / repo / "git" / "commits" / sha if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "repos" / owner / repo / "git" / "commits" if apiVersionMatch(_req) =>
      post(_req, owner, repo, _req.attemptAs[io.flow.github.v0.models.CommitForm]).flatMap {
        case PostResponse.HTTP201(value, headers) => Created(value).putHeaders(headers: _*)
        case PostResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value).putHeaders(headers: _*)
        case PostResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "repos" / owner / repo / "git" / "commits" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait ContentsRoutes {

  import Matchers._

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A]) = org.http4s.circe.jsonOf[A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[A]

  sealed trait GetReadmeResponse

  object GetReadmeResponse {
    case class HTTP200(value: io.flow.github.v0.models.Contents, headers: Seq[org.http4s.Header] = Nil) extends GetReadmeResponse
    case class HTTP401(challenge: org.http4s.Challenge, challenges: Seq[org.http4s.Challenge] = Nil, headers: Seq[org.http4s.Header] = Nil) extends GetReadmeResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends GetReadmeResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetReadmeResponse
  }

  def getReadme(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    ref: String
  ): scalaz.concurrent.Task[GetReadmeResponse]

  sealed trait GetContentsByPathResponse

  object GetContentsByPathResponse {
    case class HTTP200(value: io.flow.github.v0.models.Contents, headers: Seq[org.http4s.Header] = Nil) extends GetContentsByPathResponse
    case class HTTP401(challenge: org.http4s.Challenge, challenges: Seq[org.http4s.Challenge] = Nil, headers: Seq[org.http4s.Header] = Nil) extends GetContentsByPathResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends GetContentsByPathResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetContentsByPathResponse
  }

  def getContentsByPath(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    path: String,
    ref: String
  ): scalaz.concurrent.Task[GetContentsByPathResponse]

  def apiVersionMatch(req: org.http4s.Message): Boolean = ApiVersion(req)

  def service() = org.http4s.HttpService {
    case _req @ GET -> Root / "repos" / owner / repo / "readme" :? RefStringDefMasterMatcher(ref) if apiVersionMatch(_req) =>
      getReadme(_req, owner, repo, ref).flatMap {
        case GetReadmeResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetReadmeResponse.HTTP401(challenge, challenges, headers) => Unauthorized(challenge, challenges: _*).putHeaders(headers: _*)
        case GetReadmeResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case GetReadmeResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "repos" / owner / repo / "readme" :? RefStringDefMasterMatcher(ref) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "repos" / owner / repo / "contents" / path :? RefStringDefMasterMatcher(ref) if apiVersionMatch(_req) =>
      getContentsByPath(_req, owner, repo, path, ref).flatMap {
        case GetContentsByPathResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetContentsByPathResponse.HTTP401(challenge, challenges, headers) => Unauthorized(challenge, challenges: _*).putHeaders(headers: _*)
        case GetContentsByPathResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case GetContentsByPathResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "repos" / owner / repo / "contents" / path :? RefStringDefMasterMatcher(ref) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait HookRoutes {

  import Matchers._

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A]) = org.http4s.circe.jsonOf[A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[A]

  sealed trait GetResponse

  object GetResponse {
    case class HTTP200(value: Seq[io.flow.github.v0.models.Hook], headers: Seq[org.http4s.Header] = Nil) extends GetResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends GetResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetResponse
  }

  def get(
    _req: org.http4s.Request,
    owner: String,
    repo: String
  ): scalaz.concurrent.Task[GetResponse]

  sealed trait GetByIdResponse

  object GetByIdResponse {
    case class HTTP200(value: io.flow.github.v0.models.Hook, headers: Seq[org.http4s.Header] = Nil) extends GetByIdResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends GetByIdResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetByIdResponse
  }

  def getById(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    id: Long
  ): scalaz.concurrent.Task[GetByIdResponse]

  sealed trait PostResponse

  object PostResponse {
    case class HTTP201(value: io.flow.github.v0.models.Hook, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP422(value: io.flow.github.v0.models.UnprocessableEntity, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends PostResponse
  }

  def post(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    body: => org.http4s.DecodeResult[io.flow.github.v0.models.HookForm]
  ): scalaz.concurrent.Task[PostResponse]

  sealed trait DeleteByIdResponse

  object DeleteByIdResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends DeleteByIdResponse
  }

  def deleteById(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    id: Long
  ): scalaz.concurrent.Task[DeleteByIdResponse]

  def apiVersionMatch(req: org.http4s.Message): Boolean = ApiVersion(req)

  def service() = org.http4s.HttpService {
    case _req @ GET -> Root / "repos" / owner / repo / "hooks" if apiVersionMatch(_req) =>
      get(_req, owner, repo).flatMap {
        case GetResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case GetResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "repos" / owner / repo / "hooks" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "repos" / owner / repo / "hooks" / LongVal(id) if apiVersionMatch(_req) =>
      getById(_req, owner, repo, id).flatMap {
        case GetByIdResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetByIdResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case GetByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "repos" / owner / repo / "hooks" / LongVal(id) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "repos" / owner / repo / "hooks" if apiVersionMatch(_req) =>
      post(_req, owner, repo, _req.attemptAs[io.flow.github.v0.models.HookForm]).flatMap {
        case PostResponse.HTTP201(value, headers) => Created(value).putHeaders(headers: _*)
        case PostResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value).putHeaders(headers: _*)
        case PostResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "repos" / owner / repo / "hooks" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ DELETE -> Root / "repos" / owner / repo / "hooks" / LongVal(id) if apiVersionMatch(_req) =>
      deleteById(_req, owner, repo, id).flatMap {
        case DeleteByIdResponse.HTTP204(headers) => NoContent().putHeaders(headers: _*)
        case DeleteByIdResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case DeleteByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ DELETE -> Root / "repos" / owner / repo / "hooks" / LongVal(id) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait PullRequestRoutes {

  import Matchers._

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A]) = org.http4s.circe.jsonOf[A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[A]

  sealed trait PostResponse

  object PostResponse {
    case class HTTP201(value: io.flow.github.v0.models.PullRequest, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP422(value: io.flow.github.v0.models.UnprocessableEntity, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends PostResponse
  }

  def post(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    body: => org.http4s.DecodeResult[io.flow.github.v0.models.PullRequestForm]
  ): scalaz.concurrent.Task[PostResponse]

  sealed trait GetResponse

  object GetResponse {
    case class HTTP200(value: Seq[io.flow.github.v0.models.PullRequest], headers: Seq[org.http4s.Header] = Nil) extends GetResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends GetResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetResponse
  }

  def get(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    page: Long
  ): scalaz.concurrent.Task[GetResponse]

  def apiVersionMatch(req: org.http4s.Message): Boolean = ApiVersion(req)

  def service() = org.http4s.HttpService {
    case _req @ POST -> Root / "repos" / owner / repo / "pulls" if apiVersionMatch(_req) =>
      post(_req, owner, repo, _req.attemptAs[io.flow.github.v0.models.PullRequestForm]).flatMap {
        case PostResponse.HTTP201(value, headers) => Created(value).putHeaders(headers: _*)
        case PostResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value).putHeaders(headers: _*)
        case PostResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "repos" / owner / repo / "pulls" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "repos" / owner / repo / "pulls" :? PageLongDef1Matcher(page) if apiVersionMatch(_req) =>
      get(_req, owner, repo, page).flatMap {
        case GetResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case GetResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "repos" / owner / repo / "pulls" :? PageLongDef1Matcher(page) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait RefRoutes {

  import Matchers._

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A]) = org.http4s.circe.jsonOf[A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[A]

  sealed trait GetResponse

  object GetResponse {
    case class HTTP200(value: Seq[io.flow.github.v0.models.Ref], headers: Seq[org.http4s.Header] = Nil) extends GetResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends GetResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetResponse
  }

  def get(
    _req: org.http4s.Request,
    owner: String,
    repo: String
  ): scalaz.concurrent.Task[GetResponse]

  sealed trait GetByRefResponse

  object GetByRefResponse {
    case class HTTP200(value: io.flow.github.v0.models.Ref, headers: Seq[org.http4s.Header] = Nil) extends GetByRefResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends GetByRefResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetByRefResponse
  }

  def getByRef(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    ref: String
  ): scalaz.concurrent.Task[GetByRefResponse]

  sealed trait PostResponse

  object PostResponse {
    case class HTTP201(value: io.flow.github.v0.models.Ref, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP422(value: io.flow.github.v0.models.UnprocessableEntity, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends PostResponse
  }

  def post(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    body: => org.http4s.DecodeResult[io.flow.github.v0.models.RefForm]
  ): scalaz.concurrent.Task[PostResponse]

  sealed trait PutByRefResponse

  object PutByRefResponse {
    case class HTTP201(value: io.flow.github.v0.models.Ref, headers: Seq[org.http4s.Header] = Nil) extends PutByRefResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends PutByRefResponse
    case class HTTP422(value: io.flow.github.v0.models.UnprocessableEntity, headers: Seq[org.http4s.Header] = Nil) extends PutByRefResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends PutByRefResponse
  }

  def putByRef(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    ref: String,
    body: => org.http4s.DecodeResult[io.flow.github.v0.models.RefUpdateForm]
  ): scalaz.concurrent.Task[PutByRefResponse]

  def apiVersionMatch(req: org.http4s.Message): Boolean = ApiVersion(req)

  def service() = org.http4s.HttpService {
    case _req @ GET -> Root / "repos" / owner / repo / "git" / "refs" if apiVersionMatch(_req) =>
      get(_req, owner, repo).flatMap {
        case GetResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case GetResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "repos" / owner / repo / "git" / "refs" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "repos" / owner / repo / "git" / "refs" / ref if apiVersionMatch(_req) =>
      getByRef(_req, owner, repo, ref).flatMap {
        case GetByRefResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetByRefResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case GetByRefResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "repos" / owner / repo / "git" / "refs" / ref if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "repos" / owner / repo / "git" / "refs" if apiVersionMatch(_req) =>
      post(_req, owner, repo, _req.attemptAs[io.flow.github.v0.models.RefForm]).flatMap {
        case PostResponse.HTTP201(value, headers) => Created(value).putHeaders(headers: _*)
        case PostResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value).putHeaders(headers: _*)
        case PostResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "repos" / owner / repo / "git" / "refs" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ PUT -> Root / "repos" / owner / repo / "git" / "refs" / ref if apiVersionMatch(_req) =>
      putByRef(_req, owner, repo, ref, _req.attemptAs[io.flow.github.v0.models.RefUpdateForm]).flatMap {
        case PutByRefResponse.HTTP201(value, headers) => Created(value).putHeaders(headers: _*)
        case PutByRefResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case PutByRefResponse.HTTP422(value, headers) => UnprocessableEntity(value).putHeaders(headers: _*)
        case PutByRefResponse.UndocumentedResponse(response) => response
      }
    case _req @ PUT -> Root / "repos" / owner / repo / "git" / "refs" / ref if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait RepositoryRoutes {

  import Matchers._

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A]) = org.http4s.circe.jsonOf[A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[A]

  sealed trait GetUserAndReposResponse

  object GetUserAndReposResponse {
    case class HTTP200(value: Seq[io.flow.github.v0.models.Repository], headers: Seq[org.http4s.Header] = Nil) extends GetUserAndReposResponse
    case class HTTP401(challenge: org.http4s.Challenge, challenges: Seq[org.http4s.Challenge] = Nil, headers: Seq[org.http4s.Header] = Nil) extends GetUserAndReposResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetUserAndReposResponse
  }

  def getUserAndRepos(
    _req: org.http4s.Request,
    page: Long,
    visibility: io.flow.github.v0.models.Visibility,
    affiliation: _root_.scala.Option[String],
    `type`: _root_.scala.Option[String],
    sort: String,
    direction: String
  ): scalaz.concurrent.Task[GetUserAndReposResponse]

  sealed trait GetUsersAndReposByUsernameResponse

  object GetUsersAndReposByUsernameResponse {
    case class HTTP200(value: Seq[io.flow.github.v0.models.Repository], headers: Seq[org.http4s.Header] = Nil) extends GetUsersAndReposByUsernameResponse
    case class HTTP401(challenge: org.http4s.Challenge, challenges: Seq[org.http4s.Challenge] = Nil, headers: Seq[org.http4s.Header] = Nil) extends GetUsersAndReposByUsernameResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetUsersAndReposByUsernameResponse
  }

  def getUsersAndReposByUsername(
    _req: org.http4s.Request,
    username: String,
    page: Long,
    `type`: String,
    sort: String,
    direction: String
  ): scalaz.concurrent.Task[GetUsersAndReposByUsernameResponse]

  sealed trait GetOrgsAndReposByOrgResponse

  object GetOrgsAndReposByOrgResponse {
    case class HTTP200(value: Seq[io.flow.github.v0.models.Repository], headers: Seq[org.http4s.Header] = Nil) extends GetOrgsAndReposByOrgResponse
    case class HTTP401(challenge: org.http4s.Challenge, challenges: Seq[org.http4s.Challenge] = Nil, headers: Seq[org.http4s.Header] = Nil) extends GetOrgsAndReposByOrgResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetOrgsAndReposByOrgResponse
  }

  def getOrgsAndReposByOrg(
    _req: org.http4s.Request,
    org: String,
    page: Long,
    `type`: String,
    sort: String,
    direction: String
  ): scalaz.concurrent.Task[GetOrgsAndReposByOrgResponse]

  def apiVersionMatch(req: org.http4s.Message): Boolean = ApiVersion(req)

  def service() = org.http4s.HttpService {
    case _req @ GET -> Root / "user" / "repos" :? PageLongDef1Matcher(page) +& VisibilityVisibilityDefAllMatcher(visibility) +& AffiliationOptStringMatcher(affiliation) +& TypeOptStringMatcher(`type`) +& SortStringDefFullNameMatcher(sort) +& DirectionStringDefAscMatcher(direction) if apiVersionMatch(_req) =>
      getUserAndRepos(_req, page, visibility, affiliation, `type`, sort, direction).flatMap {
        case GetUserAndReposResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetUserAndReposResponse.HTTP401(challenge, challenges, headers) => Unauthorized(challenge, challenges: _*).putHeaders(headers: _*)
        case GetUserAndReposResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "user" / "repos" :? PageLongDef1Matcher(page) +& VisibilityVisibilityDefAllMatcher(visibility) +& AffiliationOptStringMatcher(affiliation) +& TypeOptStringMatcher(`type`) +& SortStringDefFullNameMatcher(sort) +& DirectionStringDefAscMatcher(direction) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "users" / username / "repos" :? PageLongDef1Matcher(page) +& TypeStringDefOwnerMatcher(`type`) +& SortStringDefFullNameMatcher(sort) +& DirectionStringDefAscMatcher(direction) if apiVersionMatch(_req) =>
      getUsersAndReposByUsername(_req, username, page, `type`, sort, direction).flatMap {
        case GetUsersAndReposByUsernameResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetUsersAndReposByUsernameResponse.HTTP401(challenge, challenges, headers) => Unauthorized(challenge, challenges: _*).putHeaders(headers: _*)
        case GetUsersAndReposByUsernameResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "users" / username / "repos" :? PageLongDef1Matcher(page) +& TypeStringDefOwnerMatcher(`type`) +& SortStringDefFullNameMatcher(sort) +& DirectionStringDefAscMatcher(direction) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "orgs" / org / "repos" :? PageLongDef1Matcher(page) +& TypeStringDefAllMatcher(`type`) +& SortStringDefFullNameMatcher(sort) +& DirectionStringDefAscMatcher(direction) if apiVersionMatch(_req) =>
      getOrgsAndReposByOrg(_req, org, page, `type`, sort, direction).flatMap {
        case GetOrgsAndReposByOrgResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetOrgsAndReposByOrgResponse.HTTP401(challenge, challenges, headers) => Unauthorized(challenge, challenges: _*).putHeaders(headers: _*)
        case GetOrgsAndReposByOrgResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "orgs" / org / "repos" :? PageLongDef1Matcher(page) +& TypeStringDefAllMatcher(`type`) +& SortStringDefFullNameMatcher(sort) +& DirectionStringDefAscMatcher(direction) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait TagRoutes {

  import Matchers._

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A]) = org.http4s.circe.jsonOf[A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[A]

  sealed trait GetTagsResponse

  object GetTagsResponse {
    case class HTTP200(value: Seq[io.flow.github.v0.models.TagSummary], headers: Seq[org.http4s.Header] = Nil) extends GetTagsResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends GetTagsResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetTagsResponse
  }

  def getTags(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    page: Long,
    perPage: Long
  ): scalaz.concurrent.Task[GetTagsResponse]

  sealed trait GetTagsByShaResponse

  object GetTagsByShaResponse {
    case class HTTP200(value: io.flow.github.v0.models.Tag, headers: Seq[org.http4s.Header] = Nil) extends GetTagsByShaResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends GetTagsByShaResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetTagsByShaResponse
  }

  def getTagsBySha(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    sha: String
  ): scalaz.concurrent.Task[GetTagsByShaResponse]

  sealed trait PostGitAndTagsResponse

  object PostGitAndTagsResponse {
    case class HTTP201(value: io.flow.github.v0.models.Tag, headers: Seq[org.http4s.Header] = Nil) extends PostGitAndTagsResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends PostGitAndTagsResponse
    case class HTTP422(value: io.flow.github.v0.models.UnprocessableEntity, headers: Seq[org.http4s.Header] = Nil) extends PostGitAndTagsResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends PostGitAndTagsResponse
  }

  def postGitAndTags(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    body: => org.http4s.DecodeResult[io.flow.github.v0.models.TagForm]
  ): scalaz.concurrent.Task[PostGitAndTagsResponse]

  def apiVersionMatch(req: org.http4s.Message): Boolean = ApiVersion(req)

  def service() = org.http4s.HttpService {
    case _req @ GET -> Root / "repos" / owner / repo / "tags" :? PageLongDef1Matcher(page) +& PerPageLongDef30Matcher(perPage) if apiVersionMatch(_req) =>
      getTags(_req, owner, repo, page, perPage).flatMap {
        case GetTagsResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetTagsResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case GetTagsResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "repos" / owner / repo / "tags" :? PageLongDef1Matcher(page) +& PerPageLongDef30Matcher(perPage) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "repos" / owner / repo / "tags" / sha if apiVersionMatch(_req) =>
      getTagsBySha(_req, owner, repo, sha).flatMap {
        case GetTagsByShaResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetTagsByShaResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case GetTagsByShaResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "repos" / owner / repo / "tags" / sha if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "repos" / owner / repo / "git" / "tags" if apiVersionMatch(_req) =>
      postGitAndTags(_req, owner, repo, _req.attemptAs[io.flow.github.v0.models.TagForm]).flatMap {
        case PostGitAndTagsResponse.HTTP201(value, headers) => Created(value).putHeaders(headers: _*)
        case PostGitAndTagsResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case PostGitAndTagsResponse.HTTP422(value, headers) => UnprocessableEntity(value).putHeaders(headers: _*)
        case PostGitAndTagsResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "repos" / owner / repo / "git" / "tags" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait TreeRoutes {

  import Matchers._

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A]) = org.http4s.circe.jsonOf[A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[A]

  sealed trait PostResponse

  object PostResponse {
    case class HTTP201(value: io.flow.github.v0.models.CreateTreeResponse, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP422(value: io.flow.github.v0.models.UnprocessableEntity, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends PostResponse
  }

  def post(
    _req: org.http4s.Request,
    owner: String,
    repo: String,
    body: => org.http4s.DecodeResult[io.flow.github.v0.models.CreateTreeForm]
  ): scalaz.concurrent.Task[PostResponse]

  def apiVersionMatch(req: org.http4s.Message): Boolean = ApiVersion(req)

  def service() = org.http4s.HttpService {
    case _req @ POST -> Root / "repos" / owner / repo / "git" / "trees" if apiVersionMatch(_req) =>
      post(_req, owner, repo, _req.attemptAs[io.flow.github.v0.models.CreateTreeForm]).flatMap {
        case PostResponse.HTTP201(value, headers) => Created(value).putHeaders(headers: _*)
        case PostResponse.HTTP404(headers) => NotFound().putHeaders(headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value).putHeaders(headers: _*)
        case PostResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "repos" / owner / repo / "git" / "trees" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait UserEmailRoutes {

  import Matchers._

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A]) = org.http4s.circe.jsonOf[A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[A]

  sealed trait GetResponse

  object GetResponse {
    case class HTTP200(value: Seq[io.flow.github.v0.models.UserEmail], headers: Seq[org.http4s.Header] = Nil) extends GetResponse
    case class HTTP401(challenge: org.http4s.Challenge, challenges: Seq[org.http4s.Challenge] = Nil, headers: Seq[org.http4s.Header] = Nil) extends GetResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetResponse
  }

  def get(
    _req: org.http4s.Request
  ): scalaz.concurrent.Task[GetResponse]

  def apiVersionMatch(req: org.http4s.Message): Boolean = ApiVersion(req)

  def service() = org.http4s.HttpService {
    case _req @ GET -> Root / "user" / "emails" if apiVersionMatch(_req) =>
      get(_req).flatMap {
        case GetResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetResponse.HTTP401(challenge, challenges, headers) => Unauthorized(challenge, challenges: _*).putHeaders(headers: _*)
        case GetResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "user" / "emails" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait UserRoutes {

  import Matchers._

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A]) = org.http4s.circe.jsonOf[A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[A]

  sealed trait GetUserResponse

  object GetUserResponse {
    case class HTTP200(value: io.flow.github.v0.models.User, headers: Seq[org.http4s.Header] = Nil) extends GetUserResponse
    case class HTTP401(challenge: org.http4s.Challenge, challenges: Seq[org.http4s.Challenge] = Nil, headers: Seq[org.http4s.Header] = Nil) extends GetUserResponse
    case class UndocumentedResponse(response: scalaz.concurrent.Task[org.http4s.Response]) extends GetUserResponse
  }

  def getUser(
    _req: org.http4s.Request
  ): scalaz.concurrent.Task[GetUserResponse]

  def apiVersionMatch(req: org.http4s.Message): Boolean = ApiVersion(req)

  def service() = org.http4s.HttpService {
    case _req @ GET -> Root / "user" if apiVersionMatch(_req) =>
      getUser(_req).flatMap {
        case GetUserResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetUserResponse.HTTP401(challenge, challenges, headers) => Unauthorized(challenge, challenges: _*).putHeaders(headers: _*)
        case GetUserResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "user" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}