/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.4.67
 * User agent: apibuilder app.apibuilder.io/flow/github/0.4.67/http4s_0_20
 */
package io.flow.github.v0.server

import org.http4s.circe.decodeUri
import org.http4s.circe.encodeUri
import org.http4s.dsl.{io => _, _}
import org.http4s.implicits._
import cats.effect._
import cats.implicits._
import io.flow.github.v0.models.json._

private[server] trait Matchers[F[_]] extends Http4sDsl[F] {

  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[F]): 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 PerPageOptLongTo100Matcher extends OptionalQueryParamDecoderMatcher[Long]("per_page") {
    override def unapply(params: Map[String, Seq[String]]) = super.unapply(params).filter(_.forall(_ <= 100))
  }

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

  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[F[_]] extends Matchers[F] {

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A], sync: Sync[F]) = org.http4s.circe.jsonOf[F, A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A], sync: Sync[F]) = org.http4s.circe.jsonEncoderOf[F, 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: F[org.http4s.Response[F]]) extends GetByShaResponse
  }

  def getBySha(
    _req: org.http4s.Request[F],
    owner: String,
    repo: String,
    sha: String
  ): F[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: F[org.http4s.Response[F]]) extends PostResponse
  }

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

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

  def service()(implicit sync: Sync[F]) = org.http4s.HttpRoutes.of[F] {
    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, headers: _*)
        case GetByShaResponse.HTTP404(headers) => NotFound(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, headers: _*)
        case PostResponse.HTTP404(headers) => NotFound(headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value, 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[F[_]] extends Matchers[F] {

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A], sync: Sync[F]) = org.http4s.circe.jsonOf[F, A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A], sync: Sync[F]) = org.http4s.circe.jsonEncoderOf[F, 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: F[org.http4s.Response[F]]) extends GetByShaResponse
  }

  def getBySha(
    _req: org.http4s.Request[F],
    owner: String,
    repo: String,
    sha: String
  ): F[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: F[org.http4s.Response[F]]) extends PostResponse
  }

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

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

  def service()(implicit sync: Sync[F]) = org.http4s.HttpRoutes.of[F] {
    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, headers: _*)
        case GetByShaResponse.HTTP404(headers) => NotFound(headers: _*)
        case GetByShaResponse.HTTP422(value, headers) => UnprocessableEntity(value, 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, headers: _*)
        case PostResponse.HTTP404(headers) => NotFound(headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value, 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[F[_]] extends Matchers[F] {

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A], sync: Sync[F]) = org.http4s.circe.jsonOf[F, A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A], sync: Sync[F]) = org.http4s.circe.jsonEncoderOf[F, 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(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends GetReadmeResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends GetReadmeResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetReadmeResponse
  }

  def getReadme(
    _req: org.http4s.Request[F],
    owner: String,
    repo: String,
    ref: String
  ): F[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(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends GetContentsByPathResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends GetContentsByPathResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetContentsByPathResponse
  }

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

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

  def service()(implicit sync: Sync[F]) = org.http4s.HttpRoutes.of[F] {
    case _req @ GET -> Root / "repos" / owner / repo / "readme" :? RefStringDefMainMatcher(ref) if apiVersionMatch(_req) =>
      getReadme(_req, owner, repo, ref).flatMap {
        case GetReadmeResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetReadmeResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case GetReadmeResponse.HTTP404(headers) => NotFound(headers: _*)
        case GetReadmeResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "repos" / owner / repo / "readme" :? RefStringDefMainMatcher(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 :? RefStringDefMainMatcher(ref) if apiVersionMatch(_req) =>
      getContentsByPath(_req, owner, repo, path, ref).flatMap {
        case GetContentsByPathResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetContentsByPathResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case GetContentsByPathResponse.HTTP404(headers) => NotFound(headers: _*)
        case GetContentsByPathResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "repos" / owner / repo / "contents" / path :? RefStringDefMainMatcher(ref) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait HookRoutes[F[_]] extends Matchers[F] {

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A], sync: Sync[F]) = org.http4s.circe.jsonOf[F, A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A], sync: Sync[F]) = org.http4s.circe.jsonEncoderOf[F, 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: F[org.http4s.Response[F]]) extends GetResponse
  }

  def get(
    _req: org.http4s.Request[F],
    owner: String,
    repo: String
  ): F[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: F[org.http4s.Response[F]]) extends GetByIdResponse
  }

  def getById(
    _req: org.http4s.Request[F],
    owner: String,
    repo: String,
    id: Long
  ): F[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: F[org.http4s.Response[F]]) extends PostResponse
  }

  def post(
    _req: org.http4s.Request[F],
    owner: String,
    repo: String,
    body: => org.http4s.DecodeResult[F, io.flow.github.v0.models.HookForm]
  ): F[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: F[org.http4s.Response[F]]) extends DeleteByIdResponse
  }

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

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

  def service()(implicit sync: Sync[F]) = org.http4s.HttpRoutes.of[F] {
    case _req @ GET -> Root / "repos" / owner / repo / "hooks" if apiVersionMatch(_req) =>
      get(_req, owner, repo).flatMap {
        case GetResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetResponse.HTTP404(headers) => NotFound(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, headers: _*)
        case GetByIdResponse.HTTP404(headers) => NotFound(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, headers: _*)
        case PostResponse.HTTP404(headers) => NotFound(headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value, 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(headers: _*)
        case DeleteByIdResponse.HTTP404(headers) => NotFound(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[F[_]] extends Matchers[F] {

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A], sync: Sync[F]) = org.http4s.circe.jsonOf[F, A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A], sync: Sync[F]) = org.http4s.circe.jsonEncoderOf[F, 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: F[org.http4s.Response[F]]) extends PostResponse
  }

  def post(
    _req: org.http4s.Request[F],
    owner: String,
    repo: String,
    body: => org.http4s.DecodeResult[F, io.flow.github.v0.models.PullRequestForm]
  ): F[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: F[org.http4s.Response[F]]) extends GetResponse
  }

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

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

  def service()(implicit sync: Sync[F]) = org.http4s.HttpRoutes.of[F] {
    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, headers: _*)
        case PostResponse.HTTP404(headers) => NotFound(headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value, 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, headers: _*)
        case GetResponse.HTTP404(headers) => NotFound(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[F[_]] extends Matchers[F] {

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A], sync: Sync[F]) = org.http4s.circe.jsonOf[F, A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A], sync: Sync[F]) = org.http4s.circe.jsonEncoderOf[F, 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: F[org.http4s.Response[F]]) extends GetResponse
  }

  def get(
    _req: org.http4s.Request[F],
    owner: String,
    repo: String
  ): F[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: F[org.http4s.Response[F]]) extends GetByRefResponse
  }

  def getByRef(
    _req: org.http4s.Request[F],
    owner: String,
    repo: String,
    ref: String
  ): F[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: F[org.http4s.Response[F]]) extends PostResponse
  }

  def post(
    _req: org.http4s.Request[F],
    owner: String,
    repo: String,
    body: => org.http4s.DecodeResult[F, io.flow.github.v0.models.RefForm]
  ): F[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: F[org.http4s.Response[F]]) extends PutByRefResponse
  }

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

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

  def service()(implicit sync: Sync[F]) = org.http4s.HttpRoutes.of[F] {
    case _req @ GET -> Root / "repos" / owner / repo / "git" / "refs" if apiVersionMatch(_req) =>
      get(_req, owner, repo).flatMap {
        case GetResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetResponse.HTTP404(headers) => NotFound(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, headers: _*)
        case GetByRefResponse.HTTP404(headers) => NotFound(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, headers: _*)
        case PostResponse.HTTP404(headers) => NotFound(headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value, 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, headers: _*)
        case PutByRefResponse.HTTP404(headers) => NotFound(headers: _*)
        case PutByRefResponse.HTTP422(value, headers) => UnprocessableEntity(value, 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[F[_]] extends Matchers[F] {

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A], sync: Sync[F]) = org.http4s.circe.jsonOf[F, A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A], sync: Sync[F]) = org.http4s.circe.jsonEncoderOf[F, 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(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends GetUserAndReposResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetUserAndReposResponse
  }

  def getUserAndRepos(
    _req: org.http4s.Request[F],
    page: Long,
    visibility: io.flow.github.v0.models.Visibility,
    affiliation: _root_.scala.Option[String],
    `type`: _root_.scala.Option[String],
    sort: String,
    direction: String
  ): F[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(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends GetUsersAndReposByUsernameResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetUsersAndReposByUsernameResponse
  }

  def getUsersAndReposByUsername(
    _req: org.http4s.Request[F],
    username: String,
    page: Long,
    `type`: String,
    sort: String,
    direction: String
  ): F[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(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends GetOrgsAndReposByOrgResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetOrgsAndReposByOrgResponse
  }

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

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

  def service()(implicit sync: Sync[F]) = org.http4s.HttpRoutes.of[F] {
    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, headers: _*)
        case GetUserAndReposResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, 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, headers: _*)
        case GetUsersAndReposByUsernameResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, 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, headers: _*)
        case GetOrgsAndReposByOrgResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, 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[F[_]] extends Matchers[F] {

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A], sync: Sync[F]) = org.http4s.circe.jsonOf[F, A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A], sync: Sync[F]) = org.http4s.circe.jsonEncoderOf[F, 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: F[org.http4s.Response[F]]) extends GetTagsResponse
  }

  def getTags(
    _req: org.http4s.Request[F],
    owner: String,
    repo: String,
    page: Long,
    perPage: Long
  ): F[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: F[org.http4s.Response[F]]) extends GetTagsByShaResponse
  }

  def getTagsBySha(
    _req: org.http4s.Request[F],
    owner: String,
    repo: String,
    sha: String
  ): F[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: F[org.http4s.Response[F]]) extends PostGitAndTagsResponse
  }

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

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

  def service()(implicit sync: Sync[F]) = org.http4s.HttpRoutes.of[F] {
    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, headers: _*)
        case GetTagsResponse.HTTP404(headers) => NotFound(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, headers: _*)
        case GetTagsByShaResponse.HTTP404(headers) => NotFound(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, headers: _*)
        case PostGitAndTagsResponse.HTTP404(headers) => NotFound(headers: _*)
        case PostGitAndTagsResponse.HTTP422(value, headers) => UnprocessableEntity(value, 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[F[_]] extends Matchers[F] {

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A], sync: Sync[F]) = org.http4s.circe.jsonOf[F, A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A], sync: Sync[F]) = org.http4s.circe.jsonEncoderOf[F, 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: F[org.http4s.Response[F]]) extends PostResponse
  }

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

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

  def service()(implicit sync: Sync[F]) = org.http4s.HttpRoutes.of[F] {
    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, headers: _*)
        case PostResponse.HTTP404(headers) => NotFound(headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value, 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[F[_]] extends Matchers[F] {

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A], sync: Sync[F]) = org.http4s.circe.jsonOf[F, A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A], sync: Sync[F]) = org.http4s.circe.jsonEncoderOf[F, 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(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends GetResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetResponse
  }

  def get(
    _req: org.http4s.Request[F]
  ): F[GetResponse]

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

  def service()(implicit sync: Sync[F]) = org.http4s.HttpRoutes.of[F] {
    case _req @ GET -> Root / "user" / "emails" if apiVersionMatch(_req) =>
      get(_req).flatMap {
        case GetResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, 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[F[_]] extends Matchers[F] {

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A], sync: Sync[F]) = org.http4s.circe.jsonOf[F, A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A], sync: Sync[F]) = org.http4s.circe.jsonEncoderOf[F, 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(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends GetUserResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetUserResponse
  }

  def getUser(
    _req: org.http4s.Request[F]
  ): F[GetUserResponse]

  sealed trait GetUserAndOrgsResponse

  object GetUserAndOrgsResponse {
    case class HTTP200(value: Seq[io.flow.github.v0.models.UserOrg], headers: Seq[org.http4s.Header] = Nil) extends GetUserAndOrgsResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends GetUserAndOrgsResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetUserAndOrgsResponse
  }

  def getUserAndOrgs(
    _req: org.http4s.Request[F],
    page: Long,
    perPage: _root_.scala.Option[Long]
  ): F[GetUserAndOrgsResponse]

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

  def service()(implicit sync: Sync[F]) = org.http4s.HttpRoutes.of[F] {
    case _req @ GET -> Root / "user" if apiVersionMatch(_req) =>
      getUser(_req).flatMap {
        case GetUserResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetUserResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, 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}.")

    case _req @ GET -> Root / "user" / "orgs" :? PageLongDef1Matcher(page) +& PerPageOptLongTo100Matcher(perPage) if apiVersionMatch(_req) =>
      getUserAndOrgs(_req, page, perPage).flatMap {
        case GetUserAndOrgsResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetUserAndOrgsResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case GetUserAndOrgsResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "user" / "orgs" :? PageLongDef1Matcher(page) +& PerPageOptLongTo100Matcher(perPage) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}