/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.8.18
 * User agent: apibuilder app.apibuilder.io/flow/dependency/0.8.18/http4s_0_20
 */
package io.flow.dependency.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.common.v0.models.json._
import io.flow.dependency.v0.models.json._
import io.flow.error.v0.models.json._
import io.flow.github.v0.models.json._
import io.flow.healthcheck.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 roleQueryParamDecoder: org.http4s.QueryParamDecoder[io.flow.dependency.v0.models.Role] =
    org.http4s.QueryParamDecoder.fromUnsafeCast[io.flow.dependency.v0.models.Role](p => io.flow.dependency.v0.models.Role.fromString(p.value).get)("io.flow.dependency.v0.models.Role")

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

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

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

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

  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 ArtifactIdOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("artifact_id")

  object BinaryIdOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("binary_id")

  object BinaryOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("binary")

  object EmailOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("email")

  object EventOptSyncEventMatcher extends OptionalQueryParamDecoderMatcher[io.flow.dependency.v0.models.SyncEvent]("event")

  object ExistingProjectOptBooleanMatcher extends OptionalQueryParamDecoderMatcher[Boolean]("existing_project")

  object GroupIdOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("group_id")

  object IdListStringMatcher extends OptionalMultiQueryParamDecoderMatcher[String]("id")

  object IdOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("id")

  object IdentifierOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("identifier")

  object IdsListStringMatcher extends OptionalMultiQueryParamDecoderMatcher[String]("ids")

  object IsSyncedOptBooleanMatcher extends OptionalQueryParamDecoderMatcher[Boolean]("is_synced")

  object KeyOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("key")

  object LibraryIdOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("library_id")

  object LimitLong0To100Def25Matcher extends QueryParamDecoderMatcher[Long]("limit") {
    override def unapply(params: Map[String, Seq[String]]) = super.unapply(params).orElse(Some(25L)).filter(v => v >= 0 && v <= 100)
  }

  object NameOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("name")

  object ObjectIdOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("object_id")

  object OffsetLong0Def0Matcher extends QueryParamDecoderMatcher[Long]("offset") {
    override def unapply(params: Map[String, Seq[String]]) = super.unapply(params).orElse(Some(0L)).filter(_ >= 0)
  }

  object OrganizationIdOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("organization_id")

  object OrganizationOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("organization")

  object OwnerOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("owner")

  object ProjectIdOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("project_id")

  object PublicationOptPublicationMatcher extends OptionalQueryParamDecoderMatcher[io.flow.dependency.v0.models.Publication]("publication")

  object QOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("q")

  object ResolverIdOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("resolver_id")

  object RoleOptRoleMatcher extends OptionalQueryParamDecoderMatcher[io.flow.dependency.v0.models.Role]("role")

  object TypeOptRecommendationTypeMatcher extends OptionalQueryParamDecoderMatcher[io.flow.dependency.v0.models.RecommendationType]("type")

  object UserIdOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("user_id")

  object VersionOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("version")

  object VisibilityOptVisibilityMatcher extends OptionalQueryParamDecoderMatcher[io.flow.dependency.v0.models.Visibility]("visibility")
}

trait BinaryRoutes[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.dependency.v0.models.Binary], 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],
    id: _root_.scala.Option[String],
    ids: Seq[String],
    projectId: _root_.scala.Option[String],
    name: _root_.scala.Option[String],
    limit: Long,
    offset: Long
  ): F[GetResponse]

  sealed trait GetByIdResponse

  object GetByIdResponse {
    case class HTTP200(value: io.flow.dependency.v0.models.Binary, headers: Seq[org.http4s.Header] = Nil) extends GetByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, 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],
    id: String
  ): F[GetByIdResponse]

  sealed trait PostResponse

  object PostResponse {
    case class HTTP201(value: io.flow.dependency.v0.models.Binary, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    body: => org.http4s.DecodeResult[F, io.flow.dependency.v0.models.BinaryForm]
  ): F[PostResponse]

  sealed trait DeleteByIdResponse

  object DeleteByIdResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    id: String
  ): 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 / "binaries" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& ProjectIdOptStringMatcher(projectId) +& NameOptStringMatcher(name) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if apiVersionMatch(_req) =>
      get(_req, id, ids, projectId, name, limit, offset).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 / "binaries" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& ProjectIdOptStringMatcher(projectId) +& NameOptStringMatcher(name) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

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

    case _req @ POST -> Root / "binaries" if apiVersionMatch(_req) =>
      post(_req, _req.attemptAs[io.flow.dependency.v0.models.BinaryForm]).flatMap {
        case PostResponse.HTTP201(value, headers) => Created(value, headers: _*)
        case PostResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case PostResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "binaries" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ DELETE -> Root / "binaries" / id if apiVersionMatch(_req) =>
      deleteById(_req, id).flatMap {
        case DeleteByIdResponse.HTTP204(headers) => NoContent(headers: _*)
        case DeleteByIdResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case DeleteByIdResponse.HTTP404(headers) => NotFound(headers: _*)
        case DeleteByIdResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case DeleteByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ DELETE -> Root / "binaries" / id if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait BinaryVersionRoutes[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.dependency.v0.models.BinaryVersion], 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],
    id: _root_.scala.Option[String],
    ids: Seq[String],
    binaryId: _root_.scala.Option[String],
    projectId: _root_.scala.Option[String],
    limit: Long,
    offset: Long
  ): F[GetResponse]

  sealed trait GetByIdResponse

  object GetByIdResponse {
    case class HTTP200(value: io.flow.dependency.v0.models.BinaryVersion, headers: Seq[org.http4s.Header] = Nil) extends GetByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, 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],
    id: String
  ): F[GetByIdResponse]

  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 / "binary_versions" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& BinaryIdOptStringMatcher(binaryId) +& ProjectIdOptStringMatcher(projectId) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if apiVersionMatch(_req) =>
      get(_req, id, ids, binaryId, projectId, limit, offset).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 / "binary_versions" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& BinaryIdOptStringMatcher(binaryId) +& ProjectIdOptStringMatcher(projectId) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

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

trait GithubUserRoutes[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 PostGithubResponse

  object PostGithubResponse {
    case class HTTP200(value: io.flow.common.v0.models.User, headers: Seq[org.http4s.Header] = Nil) extends PostGithubResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, headers: Seq[org.http4s.Header] = Nil) extends PostGithubResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends PostGithubResponse
  }

  def postGithub(
    _req: org.http4s.Request[F],
    body: => org.http4s.DecodeResult[F, io.flow.dependency.v0.models.GithubAuthenticationForm]
  ): F[PostGithubResponse]

  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 / "authentications" / "github" if apiVersionMatch(_req) =>
      postGithub(_req, _req.attemptAs[io.flow.dependency.v0.models.GithubAuthenticationForm]).flatMap {
        case PostGithubResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case PostGithubResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case PostGithubResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "authentications" / "github" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait GithubWebhookRoutes[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 PostByProjectIdResponse

  object PostByProjectIdResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends PostByProjectIdResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends PostByProjectIdResponse
  }

  def postByProjectId(
    _req: org.http4s.Request[F],
    projectId: String
  ): F[PostByProjectIdResponse]

  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 / "webhooks" / "github" / projectId if apiVersionMatch(_req) =>
      postByProjectId(_req, projectId).flatMap {
        case PostByProjectIdResponse.HTTP204(headers) => NoContent(headers: _*)
        case PostByProjectIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "webhooks" / "github" / projectId if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait IoFlowHealthcheckV0ModelsHealthcheckRoutes[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 GetHealthcheckResponse

  object GetHealthcheckResponse {
    case class HTTP200(value: io.flow.healthcheck.v0.models.Healthcheck, headers: Seq[org.http4s.Header] = Nil) extends GetHealthcheckResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetHealthcheckResponse
  }

  def getHealthcheck(
    _req: org.http4s.Request[F]
  ): F[GetHealthcheckResponse]

  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 / "_internal_" / "healthcheck" if apiVersionMatch(_req) =>
      getHealthcheck(_req).flatMap {
        case GetHealthcheckResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetHealthcheckResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "_internal_" / "healthcheck" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait ItemRoutes[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.dependency.v0.models.Item], 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],
    q: _root_.scala.Option[String],
    limit: Long,
    offset: 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 @ GET -> Root / "items" :? QOptStringMatcher(q) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if apiVersionMatch(_req) =>
      get(_req, q, limit, offset).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 / "items" :? QOptStringMatcher(q) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait LibraryRoutes[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.dependency.v0.models.Library], 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],
    id: _root_.scala.Option[String],
    ids: Seq[String],
    projectId: _root_.scala.Option[String],
    groupId: _root_.scala.Option[String],
    artifactId: _root_.scala.Option[String],
    resolverId: _root_.scala.Option[String],
    limit: Long,
    offset: Long
  ): F[GetResponse]

  sealed trait GetByIdResponse

  object GetByIdResponse {
    case class HTTP200(value: io.flow.dependency.v0.models.Library, headers: Seq[org.http4s.Header] = Nil) extends GetByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, 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],
    id: String
  ): F[GetByIdResponse]

  sealed trait PostResponse

  object PostResponse {
    case class HTTP201(value: io.flow.dependency.v0.models.Library, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    body: => org.http4s.DecodeResult[F, io.flow.dependency.v0.models.LibraryForm]
  ): F[PostResponse]

  sealed trait DeleteByIdResponse

  object DeleteByIdResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    id: String
  ): 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 / "libraries" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& ProjectIdOptStringMatcher(projectId) +& GroupIdOptStringMatcher(groupId) +& ArtifactIdOptStringMatcher(artifactId) +& ResolverIdOptStringMatcher(resolverId) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if apiVersionMatch(_req) =>
      get(_req, id, ids, projectId, groupId, artifactId, resolverId, limit, offset).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 / "libraries" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& ProjectIdOptStringMatcher(projectId) +& GroupIdOptStringMatcher(groupId) +& ArtifactIdOptStringMatcher(artifactId) +& ResolverIdOptStringMatcher(resolverId) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

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

    case _req @ POST -> Root / "libraries" if apiVersionMatch(_req) =>
      post(_req, _req.attemptAs[io.flow.dependency.v0.models.LibraryForm]).flatMap {
        case PostResponse.HTTP201(value, headers) => Created(value, headers: _*)
        case PostResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case PostResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "libraries" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ DELETE -> Root / "libraries" / id if apiVersionMatch(_req) =>
      deleteById(_req, id).flatMap {
        case DeleteByIdResponse.HTTP204(headers) => NoContent(headers: _*)
        case DeleteByIdResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case DeleteByIdResponse.HTTP404(headers) => NotFound(headers: _*)
        case DeleteByIdResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case DeleteByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ DELETE -> Root / "libraries" / id if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait LibraryVersionRoutes[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.dependency.v0.models.LibraryVersion], 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],
    id: _root_.scala.Option[String],
    ids: Seq[String],
    libraryId: _root_.scala.Option[String],
    limit: Long,
    offset: Long
  ): F[GetResponse]

  sealed trait GetByIdResponse

  object GetByIdResponse {
    case class HTTP200(value: io.flow.dependency.v0.models.LibraryVersion, headers: Seq[org.http4s.Header] = Nil) extends GetByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, 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],
    id: String
  ): F[GetByIdResponse]

  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 / "library_versions" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& LibraryIdOptStringMatcher(libraryId) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if apiVersionMatch(_req) =>
      get(_req, id, ids, libraryId, limit, offset).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 / "library_versions" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& LibraryIdOptStringMatcher(libraryId) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

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

trait MembershipRoutes[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.dependency.v0.models.Membership], 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],
    id: _root_.scala.Option[String],
    ids: Seq[String],
    organization: _root_.scala.Option[String],
    userId: _root_.scala.Option[String],
    role: _root_.scala.Option[io.flow.dependency.v0.models.Role],
    limit: Long,
    offset: Long
  ): F[GetResponse]

  sealed trait GetByIdResponse

  object GetByIdResponse {
    case class HTTP200(value: io.flow.dependency.v0.models.Membership, headers: Seq[org.http4s.Header] = Nil) extends GetByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, 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],
    id: String
  ): F[GetByIdResponse]

  sealed trait PostResponse

  object PostResponse {
    case class HTTP201(value: io.flow.dependency.v0.models.Membership, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, 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.error.v0.models.GenericError, 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],
    body: => org.http4s.DecodeResult[F, io.flow.dependency.v0.models.MembershipForm]
  ): F[PostResponse]

  sealed trait DeleteByIdResponse

  object DeleteByIdResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    id: String
  ): 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 / "memberships" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& OrganizationOptStringMatcher(organization) +& UserIdOptStringMatcher(userId) +& RoleOptRoleMatcher(role) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if apiVersionMatch(_req) =>
      get(_req, id, ids, organization, userId, role, limit, offset).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 / "memberships" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& OrganizationOptStringMatcher(organization) +& UserIdOptStringMatcher(userId) +& RoleOptRoleMatcher(role) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

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

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

    case _req @ DELETE -> Root / "memberships" / id if apiVersionMatch(_req) =>
      deleteById(_req, id).flatMap {
        case DeleteByIdResponse.HTTP204(headers) => NoContent(headers: _*)
        case DeleteByIdResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case DeleteByIdResponse.HTTP404(headers) => NotFound(headers: _*)
        case DeleteByIdResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case DeleteByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ DELETE -> Root / "memberships" / id if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait OrganizationRoutes[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.dependency.v0.models.Organization], 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],
    id: _root_.scala.Option[String],
    ids: Seq[String],
    userId: _root_.scala.Option[String],
    key: _root_.scala.Option[String],
    limit: Long,
    offset: Long
  ): F[GetResponse]

  sealed trait GetUsersByUserIdResponse

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

  def getUsersByUserId(
    _req: org.http4s.Request[F],
    userId: String
  ): F[GetUsersByUserIdResponse]

  sealed trait GetByIdResponse

  object GetByIdResponse {
    case class HTTP200(value: io.flow.dependency.v0.models.Organization, headers: Seq[org.http4s.Header] = Nil) extends GetByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, 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],
    id: String
  ): F[GetByIdResponse]

  sealed trait PostResponse

  object PostResponse {
    case class HTTP201(value: io.flow.dependency.v0.models.Organization, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    body: => org.http4s.DecodeResult[F, io.flow.dependency.v0.models.OrganizationForm]
  ): F[PostResponse]

  sealed trait PutByIdResponse

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

  def putById(
    _req: org.http4s.Request[F],
    id: String,
    body: => org.http4s.DecodeResult[F, io.flow.dependency.v0.models.OrganizationForm]
  ): F[PutByIdResponse]

  sealed trait DeleteByIdResponse

  object DeleteByIdResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    id: String
  ): 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 / "organizations" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& UserIdOptStringMatcher(userId) +& KeyOptStringMatcher(key) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if apiVersionMatch(_req) =>
      get(_req, id, ids, userId, key, limit, offset).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 / "organizations" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& UserIdOptStringMatcher(userId) +& KeyOptStringMatcher(key) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "organizations" / "users" / userId if apiVersionMatch(_req) =>
      getUsersByUserId(_req, userId).flatMap {
        case GetUsersByUserIdResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetUsersByUserIdResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case GetUsersByUserIdResponse.HTTP404(headers) => NotFound(headers: _*)
        case GetUsersByUserIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "organizations" / "users" / userId if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

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

    case _req @ POST -> Root / "organizations" if apiVersionMatch(_req) =>
      post(_req, _req.attemptAs[io.flow.dependency.v0.models.OrganizationForm]).flatMap {
        case PostResponse.HTTP201(value, headers) => Created(value, headers: _*)
        case PostResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case PostResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "organizations" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ PUT -> Root / "organizations" / id if apiVersionMatch(_req) =>
      putById(_req, id, _req.attemptAs[io.flow.dependency.v0.models.OrganizationForm]).flatMap {
        case PutByIdResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case PutByIdResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case PutByIdResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case PutByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ PUT -> Root / "organizations" / id if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ DELETE -> Root / "organizations" / id if apiVersionMatch(_req) =>
      deleteById(_req, id).flatMap {
        case DeleteByIdResponse.HTTP204(headers) => NoContent(headers: _*)
        case DeleteByIdResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case DeleteByIdResponse.HTTP404(headers) => NotFound(headers: _*)
        case DeleteByIdResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case DeleteByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ DELETE -> Root / "organizations" / id if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait ProjectBinaryRoutes[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.dependency.v0.models.ProjectBinary], 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],
    id: _root_.scala.Option[String],
    ids: Seq[String],
    projectId: _root_.scala.Option[String],
    binaryId: _root_.scala.Option[String],
    isSynced: _root_.scala.Option[Boolean],
    limit: Long,
    offset: 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 @ GET -> Root / "project_binaries" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& ProjectIdOptStringMatcher(projectId) +& BinaryIdOptStringMatcher(binaryId) +& IsSyncedOptBooleanMatcher(isSynced) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if apiVersionMatch(_req) =>
      get(_req, id, ids, projectId, binaryId, isSynced, limit, offset).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 / "project_binaries" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& ProjectIdOptStringMatcher(projectId) +& BinaryIdOptStringMatcher(binaryId) +& IsSyncedOptBooleanMatcher(isSynced) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait ProjectDependencyResolutionRoutes[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: io.flow.dependency.v0.models.ProjectDependencyResolution, 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 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],
    organization: String,
    groupId: String
  ): 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 / organization / "project" / "dependencies" / "group" / groupId if apiVersionMatch(_req) =>
      get(_req, organization, groupId).flatMap {
        case GetResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case GetResponse.HTTP404(headers) => NotFound(headers: _*)
        case GetResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / organization / "project" / "dependencies" / "group" / groupId if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait ProjectLibraryRoutes[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.dependency.v0.models.ProjectLibrary], 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],
    id: _root_.scala.Option[String],
    ids: Seq[String],
    projectId: _root_.scala.Option[String],
    libraryId: _root_.scala.Option[String],
    isSynced: _root_.scala.Option[Boolean],
    limit: Long,
    offset: 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 @ GET -> Root / "project_libraries" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& ProjectIdOptStringMatcher(projectId) +& LibraryIdOptStringMatcher(libraryId) +& IsSyncedOptBooleanMatcher(isSynced) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if apiVersionMatch(_req) =>
      get(_req, id, ids, projectId, libraryId, isSynced, limit, offset).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 / "project_libraries" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& ProjectIdOptStringMatcher(projectId) +& LibraryIdOptStringMatcher(libraryId) +& IsSyncedOptBooleanMatcher(isSynced) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait ProjectRoutes[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.dependency.v0.models.Project], 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],
    id: _root_.scala.Option[String],
    ids: Seq[String],
    organization: _root_.scala.Option[String],
    name: _root_.scala.Option[String],
    groupId: _root_.scala.Option[String],
    artifactId: _root_.scala.Option[String],
    version: _root_.scala.Option[String],
    libraryId: _root_.scala.Option[String],
    binary: _root_.scala.Option[String],
    binaryId: _root_.scala.Option[String],
    limit: Long,
    offset: Long
  ): F[GetResponse]

  sealed trait GetByIdResponse

  object GetByIdResponse {
    case class HTTP200(value: io.flow.dependency.v0.models.Project, headers: Seq[org.http4s.Header] = Nil) extends GetByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, 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],
    id: String
  ): F[GetByIdResponse]

  sealed trait PostResponse

  object PostResponse {
    case class HTTP201(value: io.flow.dependency.v0.models.Project, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    body: => org.http4s.DecodeResult[F, io.flow.dependency.v0.models.ProjectForm]
  ): F[PostResponse]

  sealed trait PutByIdResponse

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

  def putById(
    _req: org.http4s.Request[F],
    id: String,
    body: => org.http4s.DecodeResult[F, io.flow.dependency.v0.models.ProjectForm]
  ): F[PutByIdResponse]

  sealed trait PatchByIdResponse

  object PatchByIdResponse {
    case class HTTP200(value: io.flow.dependency.v0.models.Project, headers: Seq[org.http4s.Header] = Nil) extends PatchByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends PatchByIdResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends PatchByIdResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, headers: Seq[org.http4s.Header] = Nil) extends PatchByIdResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends PatchByIdResponse
  }

  def patchById(
    _req: org.http4s.Request[F],
    id: String,
    body: => org.http4s.DecodeResult[F, io.flow.dependency.v0.models.ProjectPatchForm]
  ): F[PatchByIdResponse]

  sealed trait DeleteByIdResponse

  object DeleteByIdResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    id: String
  ): 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 / "projects" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& OrganizationOptStringMatcher(organization) +& NameOptStringMatcher(name) +& GroupIdOptStringMatcher(groupId) +& ArtifactIdOptStringMatcher(artifactId) +& VersionOptStringMatcher(version) +& LibraryIdOptStringMatcher(libraryId) +& BinaryOptStringMatcher(binary) +& BinaryIdOptStringMatcher(binaryId) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if apiVersionMatch(_req) =>
      get(_req, id, ids, organization, name, groupId, artifactId, version, libraryId, binary, binaryId, limit, offset).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 / "projects" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& OrganizationOptStringMatcher(organization) +& NameOptStringMatcher(name) +& GroupIdOptStringMatcher(groupId) +& ArtifactIdOptStringMatcher(artifactId) +& VersionOptStringMatcher(version) +& LibraryIdOptStringMatcher(libraryId) +& BinaryOptStringMatcher(binary) +& BinaryIdOptStringMatcher(binaryId) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

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

    case _req @ POST -> Root / "projects" if apiVersionMatch(_req) =>
      post(_req, _req.attemptAs[io.flow.dependency.v0.models.ProjectForm]).flatMap {
        case PostResponse.HTTP201(value, headers) => Created(value, headers: _*)
        case PostResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case PostResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "projects" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ PUT -> Root / "projects" / id if apiVersionMatch(_req) =>
      putById(_req, id, _req.attemptAs[io.flow.dependency.v0.models.ProjectForm]).flatMap {
        case PutByIdResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case PutByIdResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case PutByIdResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case PutByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ PUT -> Root / "projects" / id if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ PATCH -> Root / "projects" / id if apiVersionMatch(_req) =>
      patchById(_req, id, _req.attemptAs[io.flow.dependency.v0.models.ProjectPatchForm]).flatMap {
        case PatchByIdResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case PatchByIdResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case PatchByIdResponse.HTTP404(headers) => NotFound(headers: _*)
        case PatchByIdResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case PatchByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ PATCH -> Root / "projects" / id if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ DELETE -> Root / "projects" / id if apiVersionMatch(_req) =>
      deleteById(_req, id).flatMap {
        case DeleteByIdResponse.HTTP204(headers) => NoContent(headers: _*)
        case DeleteByIdResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case DeleteByIdResponse.HTTP404(headers) => NotFound(headers: _*)
        case DeleteByIdResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case DeleteByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ DELETE -> Root / "projects" / id if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait RecommendationRoutes[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.dependency.v0.models.Recommendation], 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],
    organization: _root_.scala.Option[String],
    projectId: _root_.scala.Option[String],
    `type`: _root_.scala.Option[io.flow.dependency.v0.models.RecommendationType],
    limit: Long,
    offset: 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 @ GET -> Root / "recommendations" :? OrganizationOptStringMatcher(organization) +& ProjectIdOptStringMatcher(projectId) +& TypeOptRecommendationTypeMatcher(`type`) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if apiVersionMatch(_req) =>
      get(_req, organization, projectId, `type`, limit, offset).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 / "recommendations" :? OrganizationOptStringMatcher(organization) +& ProjectIdOptStringMatcher(projectId) +& TypeOptRecommendationTypeMatcher(`type`) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) 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 GetGithubResponse

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

  def getGithub(
    _req: org.http4s.Request[F],
    owner: _root_.scala.Option[String],
    name: _root_.scala.Option[String],
    organizationId: _root_.scala.Option[String],
    existingProject: _root_.scala.Option[Boolean],
    limit: Long,
    offset: Long
  ): F[GetGithubResponse]

  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 / "repositories" / "github" :? OwnerOptStringMatcher(owner) +& NameOptStringMatcher(name) +& OrganizationIdOptStringMatcher(organizationId) +& ExistingProjectOptBooleanMatcher(existingProject) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if apiVersionMatch(_req) =>
      getGithub(_req, owner, name, organizationId, existingProject, limit, offset).flatMap {
        case GetGithubResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetGithubResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case GetGithubResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case GetGithubResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "repositories" / "github" :? OwnerOptStringMatcher(owner) +& NameOptStringMatcher(name) +& OrganizationIdOptStringMatcher(organizationId) +& ExistingProjectOptBooleanMatcher(existingProject) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait ResolverRoutes[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.dependency.v0.models.Resolver], 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],
    id: _root_.scala.Option[String],
    ids: Seq[String],
    organization: _root_.scala.Option[String],
    visibility: _root_.scala.Option[io.flow.dependency.v0.models.Visibility],
    limit: Long,
    offset: Long
  ): F[GetResponse]

  sealed trait GetByIdResponse

  object GetByIdResponse {
    case class HTTP200(value: io.flow.dependency.v0.models.Resolver, headers: Seq[org.http4s.Header] = Nil) extends GetByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, 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],
    id: String
  ): F[GetByIdResponse]

  sealed trait PostResponse

  object PostResponse {
    case class HTTP201(value: io.flow.dependency.v0.models.Resolver, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    body: => org.http4s.DecodeResult[F, io.flow.dependency.v0.models.ResolverForm]
  ): F[PostResponse]

  sealed trait DeleteByIdResponse

  object DeleteByIdResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    id: String
  ): 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 / "resolvers" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& OrganizationOptStringMatcher(organization) +& VisibilityOptVisibilityMatcher(visibility) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if apiVersionMatch(_req) =>
      get(_req, id, ids, organization, visibility, limit, offset).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 / "resolvers" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& OrganizationOptStringMatcher(organization) +& VisibilityOptVisibilityMatcher(visibility) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

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

    case _req @ POST -> Root / "resolvers" if apiVersionMatch(_req) =>
      post(_req, _req.attemptAs[io.flow.dependency.v0.models.ResolverForm]).flatMap {
        case PostResponse.HTTP201(value, headers) => Created(value, headers: _*)
        case PostResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case PostResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "resolvers" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ DELETE -> Root / "resolvers" / id if apiVersionMatch(_req) =>
      deleteById(_req, id).flatMap {
        case DeleteByIdResponse.HTTP204(headers) => NoContent(headers: _*)
        case DeleteByIdResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case DeleteByIdResponse.HTTP404(headers) => NotFound(headers: _*)
        case DeleteByIdResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case DeleteByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ DELETE -> Root / "resolvers" / id if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait SubscriptionRoutes[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.dependency.v0.models.Subscription], 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],
    id: _root_.scala.Option[String],
    ids: Seq[String],
    userId: _root_.scala.Option[String],
    identifier: _root_.scala.Option[String],
    publication: _root_.scala.Option[io.flow.dependency.v0.models.Publication],
    limit: Long,
    offset: Long
  ): F[GetResponse]

  sealed trait GetByIdResponse

  object GetByIdResponse {
    case class HTTP200(value: io.flow.dependency.v0.models.Subscription, headers: Seq[org.http4s.Header] = Nil) extends GetByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, 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],
    id: String
  ): F[GetByIdResponse]

  sealed trait PostResponse

  object PostResponse {
    case class HTTP201(value: io.flow.dependency.v0.models.Subscription, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    identifier: _root_.scala.Option[String],
    body: => org.http4s.DecodeResult[F, io.flow.dependency.v0.models.SubscriptionForm]
  ): F[PostResponse]

  sealed trait DeleteByIdResponse

  object DeleteByIdResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    id: String,
    identifier: _root_.scala.Option[String]
  ): 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 / "subscriptions" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& UserIdOptStringMatcher(userId) +& IdentifierOptStringMatcher(identifier) +& PublicationOptPublicationMatcher(publication) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if apiVersionMatch(_req) =>
      get(_req, id, ids, userId, identifier, publication, limit, offset).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 / "subscriptions" :? IdOptStringMatcher(id) +& IdsListStringMatcher(cats.data.Validated.Valid(ids)) +& UserIdOptStringMatcher(userId) +& IdentifierOptStringMatcher(identifier) +& PublicationOptPublicationMatcher(publication) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

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

    case _req @ POST -> Root / "subscriptions" :? IdentifierOptStringMatcher(identifier) if apiVersionMatch(_req) =>
      post(_req, identifier, _req.attemptAs[io.flow.dependency.v0.models.SubscriptionForm]).flatMap {
        case PostResponse.HTTP201(value, headers) => Created(value, headers: _*)
        case PostResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case PostResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "subscriptions" :? IdentifierOptStringMatcher(identifier) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ DELETE -> Root / "subscriptions" / id :? IdentifierOptStringMatcher(identifier) if apiVersionMatch(_req) =>
      deleteById(_req, id, identifier).flatMap {
        case DeleteByIdResponse.HTTP204(headers) => NoContent(headers: _*)
        case DeleteByIdResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case DeleteByIdResponse.HTTP404(headers) => NotFound(headers: _*)
        case DeleteByIdResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case DeleteByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ DELETE -> Root / "subscriptions" / id :? IdentifierOptStringMatcher(identifier) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait SyncRoutes[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.dependency.v0.models.Sync], 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],
    objectId: _root_.scala.Option[String],
    event: _root_.scala.Option[io.flow.dependency.v0.models.SyncEvent],
    limit: Long,
    offset: Long
  ): F[GetResponse]

  sealed trait PostLibrariesByOrganizationResponse

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

  def postLibrariesByOrganization(
    _req: org.http4s.Request[F],
    organization: String
  ): F[PostLibrariesByOrganizationResponse]

  sealed trait PostBinariesByIdResponse

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

  def postBinariesById(
    _req: org.http4s.Request[F],
    id: String
  ): F[PostBinariesByIdResponse]

  sealed trait PostLibrariesAndPrefixByArtifactIdPrefixResponse

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

  def postLibrariesAndPrefixByArtifactIdPrefix(
    _req: org.http4s.Request[F],
    artifactIdPrefix: String
  ): F[PostLibrariesAndPrefixByArtifactIdPrefixResponse]

  sealed trait PostLibrariesByIdResponse

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

  def postLibrariesById(
    _req: org.http4s.Request[F],
    id: String
  ): F[PostLibrariesByIdResponse]

  sealed trait PostProjectsByIdResponse

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

  def postProjectsById(
    _req: org.http4s.Request[F],
    id: String
  ): F[PostProjectsByIdResponse]

  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 / "syncs" :? ObjectIdOptStringMatcher(objectId) +& EventOptSyncEventMatcher(event) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if apiVersionMatch(_req) =>
      get(_req, objectId, event, limit, offset).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 / "syncs" :? ObjectIdOptStringMatcher(objectId) +& EventOptSyncEventMatcher(event) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "syncs" / organization / "libraries" if apiVersionMatch(_req) =>
      postLibrariesByOrganization(_req, organization).flatMap {
        case PostLibrariesByOrganizationResponse.HTTP204(headers) => NoContent(headers: _*)
        case PostLibrariesByOrganizationResponse.HTTP404(headers) => NotFound(headers: _*)
        case PostLibrariesByOrganizationResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "syncs" / organization / "libraries" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "syncs" / "binaries" / id if apiVersionMatch(_req) =>
      postBinariesById(_req, id).flatMap {
        case PostBinariesByIdResponse.HTTP204(headers) => NoContent(headers: _*)
        case PostBinariesByIdResponse.HTTP404(headers) => NotFound(headers: _*)
        case PostBinariesByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "syncs" / "binaries" / id if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "syncs" / "libraries" / "prefix" / artifactIdPrefix if apiVersionMatch(_req) =>
      postLibrariesAndPrefixByArtifactIdPrefix(_req, artifactIdPrefix).flatMap {
        case PostLibrariesAndPrefixByArtifactIdPrefixResponse.HTTP204(headers) => NoContent(headers: _*)
        case PostLibrariesAndPrefixByArtifactIdPrefixResponse.HTTP404(headers) => NotFound(headers: _*)
        case PostLibrariesAndPrefixByArtifactIdPrefixResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "syncs" / "libraries" / "prefix" / artifactIdPrefix if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "syncs" / "libraries" / id if apiVersionMatch(_req) =>
      postLibrariesById(_req, id).flatMap {
        case PostLibrariesByIdResponse.HTTP204(headers) => NoContent(headers: _*)
        case PostLibrariesByIdResponse.HTTP404(headers) => NotFound(headers: _*)
        case PostLibrariesByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "syncs" / "libraries" / id if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "syncs" / "projects" / id if apiVersionMatch(_req) =>
      postProjectsById(_req, id).flatMap {
        case PostProjectsByIdResponse.HTTP204(headers) => NoContent(headers: _*)
        case PostProjectsByIdResponse.HTTP404(headers) => NotFound(headers: _*)
        case PostProjectsByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "syncs" / "projects" / id if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait TokenRoutes[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.dependency.v0.models.Token], 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],
    id: Seq[String],
    userId: _root_.scala.Option[String],
    limit: Long,
    offset: Long
  ): F[GetResponse]

  sealed trait GetByIdResponse

  object GetByIdResponse {
    case class HTTP200(value: io.flow.dependency.v0.models.Token, headers: Seq[org.http4s.Header] = Nil) extends GetByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, 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],
    id: String
  ): F[GetByIdResponse]

  sealed trait PostResponse

  object PostResponse {
    case class HTTP201(value: io.flow.dependency.v0.models.Token, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    body: => org.http4s.DecodeResult[F, io.flow.dependency.v0.models.TokenForm]
  ): F[PostResponse]

  sealed trait DeleteByIdResponse

  object DeleteByIdResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP404(headers: Seq[org.http4s.Header] = Nil) extends DeleteByIdResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    id: String
  ): 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 / "tokens" :? IdListStringMatcher(cats.data.Validated.Valid(id)) +& UserIdOptStringMatcher(userId) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if apiVersionMatch(_req) =>
      get(_req, id, userId, limit, offset).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 / "tokens" :? IdListStringMatcher(cats.data.Validated.Valid(id)) +& UserIdOptStringMatcher(userId) +& LimitLong0To100Def25Matcher(limit) +& OffsetLong0Def0Matcher(offset) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

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

    case _req @ POST -> Root / "tokens" if apiVersionMatch(_req) =>
      post(_req, _req.attemptAs[io.flow.dependency.v0.models.TokenForm]).flatMap {
        case PostResponse.HTTP201(value, headers) => Created(value, headers: _*)
        case PostResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case PostResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case PostResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "tokens" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ DELETE -> Root / "tokens" / id if apiVersionMatch(_req) =>
      deleteById(_req, id).flatMap {
        case DeleteByIdResponse.HTTP204(headers) => NoContent(headers: _*)
        case DeleteByIdResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case DeleteByIdResponse.HTTP404(headers) => NotFound(headers: _*)
        case DeleteByIdResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case DeleteByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ DELETE -> Root / "tokens" / id if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait IoFlowCommonV0ModelsUserRoutes[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.common.v0.models.User], 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 HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    id: _root_.scala.Option[String],
    email: _root_.scala.Option[String],
    identifier: _root_.scala.Option[String]
  ): F[GetResponse]

  sealed trait GetByIdResponse

  object GetByIdResponse {
    case class HTTP200(value: io.flow.common.v0.models.User, headers: Seq[org.http4s.Header] = Nil) extends GetByIdResponse
    case class HTTP401(authenticate: org.http4s.headers.`WWW-Authenticate`, 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],
    id: String
  ): F[GetByIdResponse]

  sealed trait GetIdentifierByIdResponse

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

  def getIdentifierById(
    _req: org.http4s.Request[F],
    id: String
  ): F[GetIdentifierByIdResponse]

  sealed trait PostResponse

  object PostResponse {
    case class HTTP201(value: io.flow.common.v0.models.User, headers: Seq[org.http4s.Header] = Nil) extends PostResponse
    case class HTTP422(value: io.flow.error.v0.models.GenericError, 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],
    body: => org.http4s.DecodeResult[F, io.flow.dependency.v0.models.UserForm]
  ): 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 / "users" :? IdOptStringMatcher(id) +& EmailOptStringMatcher(email) +& IdentifierOptStringMatcher(identifier) if apiVersionMatch(_req) =>
      get(_req, id, email, identifier).flatMap {
        case GetResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case GetResponse.HTTP422(value, headers) => UnprocessableEntity(value, headers: _*)
        case GetResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "users" :? IdOptStringMatcher(id) +& EmailOptStringMatcher(email) +& IdentifierOptStringMatcher(identifier) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

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

    case _req @ GET -> Root / "users" / id / "identifier" if apiVersionMatch(_req) =>
      getIdentifierById(_req, id).flatMap {
        case GetIdentifierByIdResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetIdentifierByIdResponse.HTTP401(authenticate, headers) => Unauthorized(authenticate, headers: _*)
        case GetIdentifierByIdResponse.HTTP404(headers) => NotFound(headers: _*)
        case GetIdentifierByIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "users" / id / "identifier" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

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