/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.0.1-SNAPSHOT
 * User agent: apibuilder app.apibuilder.io/gimbalabs/hilltop-api/0.0.1-SNAPSHOT/http4s_0_22
 */
package io.gimbalabs.hilltop.api.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.gimbalabs.hilltop.api.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")


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

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

  object IntVal {
    def unapply(s: String): Option[Int] = scala.util.Try(s.toInt).toOption
  }

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

  object BlockNumberFromLongMatcher extends QueryParamDecoderMatcher[Long]("block_number_from")

  object BlockNumberFromOptLongMatcher extends OptionalQueryParamDecoderMatcher[Long]("block_number_from")

  object BlockNumberToLongMatcher extends QueryParamDecoderMatcher[Long]("block_number_to")

  object DateLocalDateMatcher extends QueryParamDecoderMatcher[_root_.java.time.LocalDate]("date")

  object EpochFromOptIntMatcher extends OptionalQueryParamDecoderMatcher[Int]("epoch_from")

  object EpochNumberIntMatcher extends QueryParamDecoderMatcher[Int]("epoch_number")

  object EpochNumberOptIntMatcher extends OptionalQueryParamDecoderMatcher[Int]("epoch_number")

  object EpochOptIntMatcher extends OptionalQueryParamDecoderMatcher[Int]("epoch")

  object EpochToOptIntMatcher extends OptionalQueryParamDecoderMatcher[Int]("epoch_to")

  object LimitOptLongMatcher extends OptionalQueryParamDecoderMatcher[Long]("limit")
}

trait ActiveStakeAmountRoutes[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.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetResponse
  }

  def get(
    _req: org.http4s.Request[F],
    epochNumber: _root_.scala.Option[Int]
  ): F[GetResponse]

  sealed trait GetByPoolBech32IdResponse

  object GetByPoolBech32IdResponse {
    case class HTTP200(value: io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetByPoolBech32IdResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetByPoolBech32IdResponse
  }

  def getByPoolBech32Id(
    _req: org.http4s.Request[F],
    poolBech32Id: String,
    epochNumber: _root_.scala.Option[Int]
  ): F[GetByPoolBech32IdResponse]

  sealed trait GetAddressesByPoolBech32IdResponse

  object GetAddressesByPoolBech32IdResponse {
    case class HTTP200(value: Seq[io.gimbalabs.hilltop.api.v0.models.AddressStakeAmount], headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetAddressesByPoolBech32IdResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetAddressesByPoolBech32IdResponse
  }

  def getAddressesByPoolBech32Id(
    _req: org.http4s.Request[F],
    poolBech32Id: String,
    epochNumber: Int
  ): F[GetAddressesByPoolBech32IdResponse]

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

    case _req @ GET -> Root / "active_stake_amounts" / poolBech32Id :? EpochNumberOptIntMatcher(epochNumber) if apiVersionMatch(_req) =>
      getByPoolBech32Id(_req, poolBech32Id, epochNumber).flatMap {
        case GetByPoolBech32IdResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetByPoolBech32IdResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "active_stake_amounts" / poolBech32Id :? EpochNumberOptIntMatcher(epochNumber) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "active_stake_amounts" / poolBech32Id / "addresses" :? EpochNumberIntMatcher(epochNumber) if apiVersionMatch(_req) =>
      getAddressesByPoolBech32Id(_req, poolBech32Id, epochNumber).flatMap {
        case GetAddressesByPoolBech32IdResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetAddressesByPoolBech32IdResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "active_stake_amounts" / poolBech32Id / "addresses" :? EpochNumberIntMatcher(epochNumber) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait BlockRoutes[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 GetBlocksInDayResponse

  object GetBlocksInDayResponse {
    case class HTTP200(value: io.gimbalabs.hilltop.api.v0.models.DayBlock, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetBlocksInDayResponse
    case class HTTP404(value: io.gimbalabs.hilltop.api.v0.models.GenericError, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetBlocksInDayResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetBlocksInDayResponse
  }

  def getBlocksInDay(
    _req: org.http4s.Request[F],
    date: _root_.java.time.LocalDate
  ): F[GetBlocksInDayResponse]

  sealed trait GetByBlockNumberResponse

  object GetByBlockNumberResponse {
    case class HTTP200(value: io.gimbalabs.hilltop.api.v0.models.Block, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetByBlockNumberResponse
    case class HTTP404(value: io.gimbalabs.hilltop.api.v0.models.GenericError, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetByBlockNumberResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetByBlockNumberResponse
  }

  def getByBlockNumber(
    _req: org.http4s.Request[F],
    blockNumber: Long
  ): F[GetByBlockNumberResponse]

  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 / "blocks" / "blocks_in_day" :? DateLocalDateMatcher(date) if apiVersionMatch(_req) =>
      getBlocksInDay(_req, date).flatMap {
        case GetBlocksInDayResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetBlocksInDayResponse.HTTP404(value, headers) => NotFound(value, headers: _*)
        case GetBlocksInDayResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "blocks" / "blocks_in_day" :? DateLocalDateMatcher(date) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "blocks" / LongVal(blockNumber) if apiVersionMatch(_req) =>
      getByBlockNumber(_req, blockNumber).flatMap {
        case GetByBlockNumberResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetByBlockNumberResponse.HTTP404(value, headers) => NotFound(value, headers: _*)
        case GetByBlockNumberResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "blocks" / LongVal(blockNumber) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait DelegationRoutes[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 GetSafePaymentByStakingAddressResponse

  object GetSafePaymentByStakingAddressResponse {
    case class HTTP200(value: String, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetSafePaymentByStakingAddressResponse
    case class HTTP404(value: io.gimbalabs.hilltop.api.v0.models.GenericError, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetSafePaymentByStakingAddressResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetSafePaymentByStakingAddressResponse
  }

  def getSafePaymentByStakingAddress(
    _req: org.http4s.Request[F],
    stakingAddress: String
  ): F[GetSafePaymentByStakingAddressResponse]

  sealed trait GetStakepoolByStakingAddressResponse

  object GetStakepoolByStakingAddressResponse {
    case class HTTP200(value: io.gimbalabs.hilltop.api.v0.models.Delegation, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetStakepoolByStakingAddressResponse
    case class HTTP404(value: io.gimbalabs.hilltop.api.v0.models.GenericError, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetStakepoolByStakingAddressResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetStakepoolByStakingAddressResponse
  }

  def getStakepoolByStakingAddress(
    _req: org.http4s.Request[F],
    stakingAddress: String
  ): F[GetStakepoolByStakingAddressResponse]

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

    case _req @ GET -> Root / "delegations" / stakingAddress / "stakepool" if apiVersionMatch(_req) =>
      getStakepoolByStakingAddress(_req, stakingAddress).flatMap {
        case GetStakepoolByStakingAddressResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetStakepoolByStakingAddressResponse.HTTP404(value, headers) => NotFound(value, headers: _*)
        case GetStakepoolByStakingAddressResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "delegations" / stakingAddress / "stakepool" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait DelegatorsCountRoutes[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 GetByPoolBech32IdResponse

  object GetByPoolBech32IdResponse {
    case class HTTP200(value: io.gimbalabs.hilltop.api.v0.models.DelegatorsCount, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetByPoolBech32IdResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetByPoolBech32IdResponse
  }

  def getByPoolBech32Id(
    _req: org.http4s.Request[F],
    poolBech32Id: String
  ): F[GetByPoolBech32IdResponse]

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

trait EpochRoutes[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 GetCurrentResponse

  object GetCurrentResponse {
    case class HTTP200(value: io.gimbalabs.hilltop.api.v0.models.Epoch, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetCurrentResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetCurrentResponse
  }

  def getCurrent(
    _req: org.http4s.Request[F]
  ): F[GetCurrentResponse]

  sealed trait GetByEpochNumberResponse

  object GetByEpochNumberResponse {
    case class HTTP200(value: io.gimbalabs.hilltop.api.v0.models.Epoch, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetByEpochNumberResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetByEpochNumberResponse
  }

  def getByEpochNumber(
    _req: org.http4s.Request[F],
    epochNumber: Int
  ): F[GetByEpochNumberResponse]

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

    case _req @ GET -> Root / "epochs" / IntVal(epochNumber) if apiVersionMatch(_req) =>
      getByEpochNumber(_req, epochNumber).flatMap {
        case GetByEpochNumberResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetByEpochNumberResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "epochs" / IntVal(epochNumber) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait HealthcheckRoutes[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.gimbalabs.hilltop.api.v0.models.Healthcheck, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetResponse
  }

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

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

  def service()(implicit sync: Sync[F]) = org.http4s.HttpRoutes.of[F] {
    case _req @ GET -> Root / "healthchecks" if apiVersionMatch(_req) =>
      get(_req).flatMap {
        case GetResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "healthchecks" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait NativeAssetRoutes[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 GetIdsResponse

  object GetIdsResponse {
    case class HTTP200(value: Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetId], headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetIdsResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetIdsResponse
  }

  def getIds(
    _req: org.http4s.Request[F],
    blockNumberFrom: _root_.scala.Option[Long],
    limit: _root_.scala.Option[Long]
  ): F[GetIdsResponse]

  sealed trait GetAssetNamesByPolicyIdResponse

  object GetAssetNamesByPolicyIdResponse {
    case class HTTP200(value: Seq[String], headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetAssetNamesByPolicyIdResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetAssetNamesByPolicyIdResponse
  }

  def getAssetNamesByPolicyId(
    _req: org.http4s.Request[F],
    policyId: String
  ): F[GetAssetNamesByPolicyIdResponse]

  sealed trait GetNftsResponse

  object GetNftsResponse {
    case class HTTP200(value: Seq[io.gimbalabs.hilltop.api.v0.models.NftDetails], headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetNftsResponse
    case class HTTP404(value: io.gimbalabs.hilltop.api.v0.models.GenericError, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetNftsResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetNftsResponse
  }

  def getNfts(
    _req: org.http4s.Request[F],
    blockNumberFrom: Long,
    blockNumberTo: Long
  ): F[GetNftsResponse]

  sealed trait PostNativeAssetsDetailsResponse

  object PostNativeAssetsDetailsResponse {
    case class HTTP200(value: Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetDetails], headers: Seq[org.http4s.Header.ToRaw] = Nil) extends PostNativeAssetsDetailsResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends PostNativeAssetsDetailsResponse
  }

  def postNativeAssetsDetails(
    _req: org.http4s.Request[F],
    body: => org.http4s.DecodeResult[F, io.gimbalabs.hilltop.api.v0.models.NativeAssetDetailsRequest]
  ): F[PostNativeAssetsDetailsResponse]

  sealed trait GetByStakeAddressResponse

  object GetByStakeAddressResponse {
    case class HTTP200(value: Seq[io.gimbalabs.hilltop.api.v0.models.NativeAsset], headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetByStakeAddressResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetByStakeAddressResponse
  }

  def getByStakeAddress(
    _req: org.http4s.Request[F],
    stakeAddress: String
  ): F[GetByStakeAddressResponse]

  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 / "native_assets" / "ids" :? BlockNumberFromOptLongMatcher(blockNumberFrom) +& LimitOptLongMatcher(limit) if apiVersionMatch(_req) =>
      getIds(_req, blockNumberFrom, limit).flatMap {
        case GetIdsResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetIdsResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "native_assets" / "ids" :? BlockNumberFromOptLongMatcher(blockNumberFrom) +& LimitOptLongMatcher(limit) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "native_assets" / policyId / "asset_names" if apiVersionMatch(_req) =>
      getAssetNamesByPolicyId(_req, policyId).flatMap {
        case GetAssetNamesByPolicyIdResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetAssetNamesByPolicyIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "native_assets" / policyId / "asset_names" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "native_assets" / "nfts" :? BlockNumberFromLongMatcher(blockNumberFrom) +& BlockNumberToLongMatcher(blockNumberTo) if apiVersionMatch(_req) =>
      getNfts(_req, blockNumberFrom, blockNumberTo).flatMap {
        case GetNftsResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetNftsResponse.HTTP404(value, headers) => NotFound(value, headers: _*)
        case GetNftsResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "native_assets" / "nfts" :? BlockNumberFromLongMatcher(blockNumberFrom) +& BlockNumberToLongMatcher(blockNumberTo) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "native_assets" / "native_assets_details" if apiVersionMatch(_req) =>
      postNativeAssetsDetails(_req, _req.attemptAs[io.gimbalabs.hilltop.api.v0.models.NativeAssetDetailsRequest]).flatMap {
        case PostNativeAssetsDetailsResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case PostNativeAssetsDetailsResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "native_assets" / "native_assets_details" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "native_assets" / stakeAddress if apiVersionMatch(_req) =>
      getByStakeAddress(_req, stakeAddress).flatMap {
        case GetByStakeAddressResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetByStakeAddressResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "native_assets" / stakeAddress if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait PoolUpdateRoutes[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 GetRetiringResponse

  object GetRetiringResponse {
    case class HTTP200(value: Seq[io.gimbalabs.hilltop.api.v0.models.PoolRetiring], headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetRetiringResponse
    case class HTTP404(value: io.gimbalabs.hilltop.api.v0.models.GenericError, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetRetiringResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetRetiringResponse
  }

  def getRetiring(
    _req: org.http4s.Request[F],
    blockNumberFrom: _root_.scala.Option[Long],
    limit: _root_.scala.Option[Long]
  ): F[GetRetiringResponse]

  sealed trait GetByPoolIdResponse

  object GetByPoolIdResponse {
    case class HTTP200(value: Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate], headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetByPoolIdResponse
    case class HTTP404(value: io.gimbalabs.hilltop.api.v0.models.GenericError, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetByPoolIdResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetByPoolIdResponse
  }

  def getByPoolId(
    _req: org.http4s.Request[F],
    poolId: String,
    blockNumberFrom: _root_.scala.Option[Long],
    limit: _root_.scala.Option[Long]
  ): F[GetByPoolIdResponse]

  sealed trait GetResponse

  object GetResponse {
    case class HTTP200(value: Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate], headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetResponse
    case class HTTP404(value: io.gimbalabs.hilltop.api.v0.models.GenericError, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetResponse
  }

  def get(
    _req: org.http4s.Request[F],
    blockNumberFrom: _root_.scala.Option[Long],
    limit: _root_.scala.Option[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 / "pool_updates" / "retiring" :? BlockNumberFromOptLongMatcher(blockNumberFrom) +& LimitOptLongMatcher(limit) if apiVersionMatch(_req) =>
      getRetiring(_req, blockNumberFrom, limit).flatMap {
        case GetRetiringResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetRetiringResponse.HTTP404(value, headers) => NotFound(value, headers: _*)
        case GetRetiringResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "pool_updates" / "retiring" :? BlockNumberFromOptLongMatcher(blockNumberFrom) +& LimitOptLongMatcher(limit) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "pool_updates" / poolId :? BlockNumberFromOptLongMatcher(blockNumberFrom) +& LimitOptLongMatcher(limit) if apiVersionMatch(_req) =>
      getByPoolId(_req, poolId, blockNumberFrom, limit).flatMap {
        case GetByPoolIdResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetByPoolIdResponse.HTTP404(value, headers) => NotFound(value, headers: _*)
        case GetByPoolIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "pool_updates" / poolId :? BlockNumberFromOptLongMatcher(blockNumberFrom) +& LimitOptLongMatcher(limit) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "pool_updates" :? BlockNumberFromOptLongMatcher(blockNumberFrom) +& LimitOptLongMatcher(limit) if apiVersionMatch(_req) =>
      get(_req, blockNumberFrom, limit).flatMap {
        case GetResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetResponse.HTTP404(value, headers) => NotFound(value, headers: _*)
        case GetResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "pool_updates" :? BlockNumberFromOptLongMatcher(blockNumberFrom) +& LimitOptLongMatcher(limit) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait RewardRoutes[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 GetByStakingAddressResponse

  object GetByStakingAddressResponse {
    case class HTTP200(value: Seq[io.gimbalabs.hilltop.api.v0.models.Reward], headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetByStakingAddressResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetByStakingAddressResponse
  }

  def getByStakingAddress(
    _req: org.http4s.Request[F],
    stakingAddress: String,
    epochFrom: _root_.scala.Option[Int],
    epochTo: _root_.scala.Option[Int]
  ): F[GetByStakingAddressResponse]

  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 / "rewards" / stakingAddress :? EpochFromOptIntMatcher(epochFrom) +& EpochToOptIntMatcher(epochTo) if apiVersionMatch(_req) =>
      getByStakingAddress(_req, stakingAddress, epochFrom, epochTo).flatMap {
        case GetByStakingAddressResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetByStakingAddressResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "rewards" / stakingAddress :? EpochFromOptIntMatcher(epochFrom) +& EpochToOptIntMatcher(epochTo) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait SigmaRoutes[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 GetByPoolIdResponse

  object GetByPoolIdResponse {
    case class HTTP200(value: io.gimbalabs.hilltop.api.v0.models.Sigma, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetByPoolIdResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetByPoolIdResponse
  }

  def getByPoolId(
    _req: org.http4s.Request[F],
    poolId: String,
    epochNumber: Int
  ): F[GetByPoolIdResponse]

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

trait StakepoolMetadataRoutes[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 GetByPoolIdBech32Response

  object GetByPoolIdBech32Response {
    case class HTTP200(value: io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetByPoolIdBech32Response
    case class HTTP404(value: io.gimbalabs.hilltop.api.v0.models.GenericError, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetByPoolIdBech32Response
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetByPoolIdBech32Response
  }

  def getByPoolIdBech32(
    _req: org.http4s.Request[F],
    poolIdBech32: String
  ): F[GetByPoolIdBech32Response]

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

trait StakepoolRoutes[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 GetVrfVkeyByVrfVkeyHashResponse

  object GetVrfVkeyByVrfVkeyHashResponse {
    case class HTTP200(value: io.gimbalabs.hilltop.api.v0.models.Stakepool, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetVrfVkeyByVrfVkeyHashResponse
    case class HTTP404(value: io.gimbalabs.hilltop.api.v0.models.GenericError, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetVrfVkeyByVrfVkeyHashResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetVrfVkeyByVrfVkeyHashResponse
  }

  def getVrfVkeyByVrfVkeyHash(
    _req: org.http4s.Request[F],
    vrfVkeyHash: String
  ): F[GetVrfVkeyByVrfVkeyHashResponse]

  sealed trait GetEstablishedEpochByPoolIdResponse

  object GetEstablishedEpochByPoolIdResponse {
    case class HTTP200(value: Int, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetEstablishedEpochByPoolIdResponse
    case class HTTP404(value: io.gimbalabs.hilltop.api.v0.models.GenericError, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetEstablishedEpochByPoolIdResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetEstablishedEpochByPoolIdResponse
  }

  def getEstablishedEpochByPoolId(
    _req: org.http4s.Request[F],
    poolId: String
  ): F[GetEstablishedEpochByPoolIdResponse]

  sealed trait GetLiveStakeByPoolIdResponse

  object GetLiveStakeByPoolIdResponse {
    case class HTTP200(value: Long, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetLiveStakeByPoolIdResponse
    case class HTTP404(value: io.gimbalabs.hilltop.api.v0.models.GenericError, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetLiveStakeByPoolIdResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetLiveStakeByPoolIdResponse
  }

  def getLiveStakeByPoolId(
    _req: org.http4s.Request[F],
    poolId: String
  ): F[GetLiveStakeByPoolIdResponse]

  sealed trait GetBlocksByPoolIdResponse

  object GetBlocksByPoolIdResponse {
    case class HTTP200(value: Int, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetBlocksByPoolIdResponse
    case class HTTP404(value: io.gimbalabs.hilltop.api.v0.models.GenericError, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetBlocksByPoolIdResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetBlocksByPoolIdResponse
  }

  def getBlocksByPoolId(
    _req: org.http4s.Request[F],
    poolId: String,
    epoch: _root_.scala.Option[Int]
  ): F[GetBlocksByPoolIdResponse]

  sealed trait GetResponse

  object GetResponse {
    case class HTTP200(value: Seq[io.gimbalabs.hilltop.api.v0.models.Stakepool], headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetResponse
  }

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

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

  def service()(implicit sync: Sync[F]) = org.http4s.HttpRoutes.of[F] {
    case _req @ GET -> Root / "stakepools" / "vrf_vkey" / vrfVkeyHash if apiVersionMatch(_req) =>
      getVrfVkeyByVrfVkeyHash(_req, vrfVkeyHash).flatMap {
        case GetVrfVkeyByVrfVkeyHashResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetVrfVkeyByVrfVkeyHashResponse.HTTP404(value, headers) => NotFound(value, headers: _*)
        case GetVrfVkeyByVrfVkeyHashResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "stakepools" / "vrf_vkey" / vrfVkeyHash if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "stakepools" / poolId / "established_epoch" if apiVersionMatch(_req) =>
      getEstablishedEpochByPoolId(_req, poolId).flatMap {
        case GetEstablishedEpochByPoolIdResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetEstablishedEpochByPoolIdResponse.HTTP404(value, headers) => NotFound(value, headers: _*)
        case GetEstablishedEpochByPoolIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "stakepools" / poolId / "established_epoch" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "stakepools" / poolId / "live_stake" if apiVersionMatch(_req) =>
      getLiveStakeByPoolId(_req, poolId).flatMap {
        case GetLiveStakeByPoolIdResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetLiveStakeByPoolIdResponse.HTTP404(value, headers) => NotFound(value, headers: _*)
        case GetLiveStakeByPoolIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "stakepools" / poolId / "live_stake" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "stakepools" / poolId / "blocks" :? EpochOptIntMatcher(epoch) if apiVersionMatch(_req) =>
      getBlocksByPoolId(_req, poolId, epoch).flatMap {
        case GetBlocksByPoolIdResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetBlocksByPoolIdResponse.HTTP404(value, headers) => NotFound(value, headers: _*)
        case GetBlocksByPoolIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "stakepools" / poolId / "blocks" :? EpochOptIntMatcher(epoch) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "stakepools" if apiVersionMatch(_req) =>
      get(_req).flatMap {
        case GetResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case GetResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "stakepools" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait TransactionRoutes[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 PostHistoryResponse

  object PostHistoryResponse {
    case class HTTP200(value: Seq[io.gimbalabs.hilltop.api.v0.models.Transaction], headers: Seq[org.http4s.Header.ToRaw] = Nil) extends PostHistoryResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends PostHistoryResponse
  }

  def postHistory(
    _req: org.http4s.Request[F],
    body: => org.http4s.DecodeResult[F, io.gimbalabs.hilltop.api.v0.models.TransactionHistoryRequest]
  ): F[PostHistoryResponse]

  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 / "transactions" / "history" if apiVersionMatch(_req) =>
      postHistory(_req, _req.attemptAs[io.gimbalabs.hilltop.api.v0.models.TransactionHistoryRequest]).flatMap {
        case PostHistoryResponse.HTTP200(value, headers) => Ok(value, headers: _*)
        case PostHistoryResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "transactions" / "history" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait WalletBalanceRoutes[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 GetByStakingAddressResponse

  object GetByStakingAddressResponse {
    case class HTTP200(value: io.gimbalabs.hilltop.api.v0.models.WalletBalance, headers: Seq[org.http4s.Header.ToRaw] = Nil) extends GetByStakingAddressResponse
    case class UndocumentedResponse(response: F[org.http4s.Response[F]]) extends GetByStakingAddressResponse
  }

  def getByStakingAddress(
    _req: org.http4s.Request[F],
    stakingAddress: String
  ): F[GetByStakingAddressResponse]

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