/**
 * 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_18
 */
package io.gimbalabs.hilltop.api.v0 {
import cats.effect._
import cats.implicits._
import io.circe.syntax._
import scala.language.higherKinds

  object Constants {

    val BaseUrl = "https://hilltop-api.mainnet.dandelion.link"
    val Namespace = "io.gimbalabs.hilltop.api.v0"
    val UserAgent = "apibuilder app.apibuilder.io/gimbalabs/hilltop-api/0.0.1-SNAPSHOT/http4s_0_18"
    val Version = "0.0.1-SNAPSHOT"
    val VersionMajor = 0

  }

  class Client[F[_]: Sync](
    val baseUrl: org.http4s.Uri = org.http4s.Uri.unsafeFromString("https://hilltop-api.mainnet.dandelion.link"),
    auth: scala.Option[io.gimbalabs.hilltop.api.v0.Authorization] = None,
    defaultHeaders: Seq[(String, String)] = Nil,
    httpClient: org.http4s.client.Client[F]
  ) extends interfaces.Client[F] {
    import org.http4s.Response
    import io.gimbalabs.hilltop.api.v0.models.json._


    def activeStakeAmounts: ActiveStakeAmounts[F] = ActiveStakeAmounts

    def blocks: Blocks[F] = Blocks

    def delegations: Delegations[F] = Delegations

    def delegatorsCounts: DelegatorsCounts[F] = DelegatorsCounts

    def epochs: Epochs[F] = Epochs

    def healthchecks: Healthchecks[F] = Healthchecks

    def nativeAssets: NativeAssets[F] = NativeAssets

    def poolUpdates: PoolUpdates[F] = PoolUpdates

    def rewards: Rewards[F] = Rewards

    def sigmas: Sigmas[F] = Sigmas

    def stakepoolMetadata: StakepoolMetadata[F] = StakepoolMetadata

    def stakepools: Stakepools[F] = Stakepools

    def transactions: Transactions[F] = Transactions

    def walletBalances: WalletBalances[F] = WalletBalances

    object ActiveStakeAmounts extends ActiveStakeAmounts[F] {
      override def get(
        epochNumber: _root_.scala.Option[Int] = None,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount] = {
        val urlPath = Seq("active_stake_amounts")

        val queryParameters = Seq(
          epochNumber.map("epoch_number" -> _.toString)
        ).flatten

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount]("io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount", r)
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }

      override def getByPoolBech32Id(
        poolBech32Id: String,
        epochNumber: _root_.scala.Option[Int] = None,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount] = {
        val urlPath = Seq("active_stake_amounts", poolBech32Id)

        val queryParameters = Seq(
          epochNumber.map("epoch_number" -> _.toString)
        ).flatten

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount]("io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount", r)
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }

      override def getAddressesByPoolBech32Id(
        poolBech32Id: String,
        epochNumber: Int,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Seq[io.gimbalabs.hilltop.api.v0.models.AddressStakeAmount]] = {
        val urlPath = Seq("active_stake_amounts", poolBech32Id, "addresses")

        val queryParameters = Seq(
          Some("epoch_number" -> epochNumber.toString)
        ).flatten

        _executeRequest[Unit, Seq[io.gimbalabs.hilltop.api.v0.models.AddressStakeAmount]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, Seq[io.gimbalabs.hilltop.api.v0.models.AddressStakeAmount]]("Seq[io.gimbalabs.hilltop.api.v0.models.AddressStakeAmount]", r)
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }
    }

    object Blocks extends Blocks[F] {
      override def getBlocksInDay(
        date: _root_.java.time.LocalDate,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.gimbalabs.hilltop.api.v0.models.DayBlock] = {
        val urlPath = Seq("blocks", "blocks_in_day")

        val queryParameters = Seq(
          Some("date" -> date.toString)
        ).flatten

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.DayBlock]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.DayBlock]("io.gimbalabs.hilltop.api.v0.models.DayBlock", r)
          case r if r.status.code == 404 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.GenericError]("io.gimbalabs.hilltop.api.v0.models.GenericError", r).flatMap(body => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }

      override def getByBlockNumber(
        blockNumber: Long,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.gimbalabs.hilltop.api.v0.models.Block] = {
        val urlPath = Seq("blocks", blockNumber.toString)

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.Block]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.Block]("io.gimbalabs.hilltop.api.v0.models.Block", r)
          case r if r.status.code == 404 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.GenericError]("io.gimbalabs.hilltop.api.v0.models.GenericError", r).flatMap(body => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }
    }

    object Delegations extends Delegations[F] {
      override def getSafePaymentByStakingAddress(
        stakingAddress: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[String] = {
        val urlPath = Seq("delegations", stakingAddress, "safe_payment")

        _executeRequest[Unit, String]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, String]("String", r)
          case r if r.status.code == 404 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.GenericError]("io.gimbalabs.hilltop.api.v0.models.GenericError", r).flatMap(body => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }

      override def getStakepoolByStakingAddress(
        stakingAddress: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.gimbalabs.hilltop.api.v0.models.Delegation] = {
        val urlPath = Seq("delegations", stakingAddress, "stakepool")

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.Delegation]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.Delegation]("io.gimbalabs.hilltop.api.v0.models.Delegation", r)
          case r if r.status.code == 404 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.GenericError]("io.gimbalabs.hilltop.api.v0.models.GenericError", r).flatMap(body => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }
    }

    object DelegatorsCounts extends DelegatorsCounts[F] {
      override def getByPoolBech32Id(
        poolBech32Id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.gimbalabs.hilltop.api.v0.models.DelegatorsCount] = {
        val urlPath = Seq("delegators_counts", poolBech32Id)

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.DelegatorsCount]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.DelegatorsCount]("io.gimbalabs.hilltop.api.v0.models.DelegatorsCount", r)
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }
    }

    object Epochs extends Epochs[F] {
      override def getCurrent(
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.gimbalabs.hilltop.api.v0.models.Epoch] = {
        val urlPath = Seq("epochs", "current")

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.Epoch]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.Epoch]("io.gimbalabs.hilltop.api.v0.models.Epoch", r)
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }

      override def getByEpochNumber(
        epochNumber: Int,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.gimbalabs.hilltop.api.v0.models.Epoch] = {
        val urlPath = Seq("epochs", epochNumber.toString)

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.Epoch]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.Epoch]("io.gimbalabs.hilltop.api.v0.models.Epoch", r)
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }
    }

    object Healthchecks extends Healthchecks[F] {
      override def get(
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.gimbalabs.hilltop.api.v0.models.Healthcheck] = {
        val urlPath = Seq("healthchecks")

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.Healthcheck]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.Healthcheck]("io.gimbalabs.hilltop.api.v0.models.Healthcheck", r)
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }
    }

    object NativeAssets extends NativeAssets[F] {
      override def getIds(
        blockNumberFrom: _root_.scala.Option[Long] = None,
        limit: _root_.scala.Option[Long] = None,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetId]] = {
        val urlPath = Seq("native_assets", "ids")

        val queryParameters = Seq(
          blockNumberFrom.map("block_number_from" -> _.toString),
          limit.map("limit" -> _.toString)
        ).flatten

        _executeRequest[Unit, Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetId]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetId]]("Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetId]", r)
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }

      override def getAssetNamesByPolicyId(
        policyId: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Seq[String]] = {
        val urlPath = Seq("native_assets", policyId, "asset_names")

        _executeRequest[Unit, Seq[String]]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, Seq[String]]("Seq[String]", r)
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }

      override def getNfts(
        blockNumberFrom: Long,
        blockNumberTo: Long,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Seq[io.gimbalabs.hilltop.api.v0.models.NftDetails]] = {
        val urlPath = Seq("native_assets", "nfts")

        val queryParameters = Seq(
          Some("block_number_from" -> blockNumberFrom.toString),
          Some("block_number_to" -> blockNumberTo.toString)
        ).flatten

        _executeRequest[Unit, Seq[io.gimbalabs.hilltop.api.v0.models.NftDetails]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, Seq[io.gimbalabs.hilltop.api.v0.models.NftDetails]]("Seq[io.gimbalabs.hilltop.api.v0.models.NftDetails]", r)
          case r if r.status.code == 404 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.GenericError]("io.gimbalabs.hilltop.api.v0.models.GenericError", r).flatMap(body => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }

      override def postNativeAssetsDetails(
        nativeAssetDetailsRequest: io.gimbalabs.hilltop.api.v0.models.NativeAssetDetailsRequest,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetDetails]] = {
        val urlPath = Seq("native_assets", "native_assets_details")

        val (payload, formPayload) = (Some(nativeAssetDetailsRequest), None)

        _executeRequest[io.gimbalabs.hilltop.api.v0.models.NativeAssetDetailsRequest, Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetDetails]]("POST", path = urlPath, body = payload, formBody = formPayload, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetDetails]]("Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetDetails]", r)
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }

      override def getByStakeAddress(
        stakeAddress: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Seq[io.gimbalabs.hilltop.api.v0.models.NativeAsset]] = {
        val urlPath = Seq("native_assets", stakeAddress)

        _executeRequest[Unit, Seq[io.gimbalabs.hilltop.api.v0.models.NativeAsset]]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, Seq[io.gimbalabs.hilltop.api.v0.models.NativeAsset]]("Seq[io.gimbalabs.hilltop.api.v0.models.NativeAsset]", r)
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }
    }

    object PoolUpdates extends PoolUpdates[F] {
      override def getRetiring(
        blockNumberFrom: _root_.scala.Option[Long] = None,
        limit: _root_.scala.Option[Long] = None,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Seq[io.gimbalabs.hilltop.api.v0.models.PoolRetiring]] = {
        val urlPath = Seq("pool_updates", "retiring")

        val queryParameters = Seq(
          blockNumberFrom.map("block_number_from" -> _.toString),
          limit.map("limit" -> _.toString)
        ).flatten

        _executeRequest[Unit, Seq[io.gimbalabs.hilltop.api.v0.models.PoolRetiring]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, Seq[io.gimbalabs.hilltop.api.v0.models.PoolRetiring]]("Seq[io.gimbalabs.hilltop.api.v0.models.PoolRetiring]", r)
          case r if r.status.code == 404 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.GenericError]("io.gimbalabs.hilltop.api.v0.models.GenericError", r).flatMap(body => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }

      override def getByPoolId(
        poolId: String,
        blockNumberFrom: _root_.scala.Option[Long] = None,
        limit: _root_.scala.Option[Long] = None,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]] = {
        val urlPath = Seq("pool_updates", poolId)

        val queryParameters = Seq(
          blockNumberFrom.map("block_number_from" -> _.toString),
          limit.map("limit" -> _.toString)
        ).flatten

        _executeRequest[Unit, Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]]("Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]", r)
          case r if r.status.code == 404 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.GenericError]("io.gimbalabs.hilltop.api.v0.models.GenericError", r).flatMap(body => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }

      override def get(
        blockNumberFrom: _root_.scala.Option[Long] = None,
        limit: _root_.scala.Option[Long] = None,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]] = {
        val urlPath = Seq("pool_updates")

        val queryParameters = Seq(
          blockNumberFrom.map("block_number_from" -> _.toString),
          limit.map("limit" -> _.toString)
        ).flatten

        _executeRequest[Unit, Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]]("Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]", r)
          case r if r.status.code == 404 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.GenericError]("io.gimbalabs.hilltop.api.v0.models.GenericError", r).flatMap(body => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }
    }

    object Rewards extends Rewards[F] {
      override def getByStakingAddress(
        stakingAddress: String,
        epochFrom: _root_.scala.Option[Int] = None,
        epochTo: _root_.scala.Option[Int] = None,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Seq[io.gimbalabs.hilltop.api.v0.models.Reward]] = {
        val urlPath = Seq("rewards", stakingAddress)

        val queryParameters = Seq(
          epochFrom.map("epoch_from" -> _.toString),
          epochTo.map("epoch_to" -> _.toString)
        ).flatten

        _executeRequest[Unit, Seq[io.gimbalabs.hilltop.api.v0.models.Reward]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, Seq[io.gimbalabs.hilltop.api.v0.models.Reward]]("Seq[io.gimbalabs.hilltop.api.v0.models.Reward]", r)
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }
    }

    object Sigmas extends Sigmas[F] {
      override def getByPoolId(
        poolId: String,
        epochNumber: Int,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.gimbalabs.hilltop.api.v0.models.Sigma] = {
        val urlPath = Seq("sigmas", poolId)

        val queryParameters = Seq(
          Some("epoch_number" -> epochNumber.toString)
        ).flatten

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.Sigma]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.Sigma]("io.gimbalabs.hilltop.api.v0.models.Sigma", r)
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }
    }

    object StakepoolMetadata extends StakepoolMetadata[F] {
      override def getByPoolIdBech32(
        poolIdBech32: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata] = {
        val urlPath = Seq("stakepool_metadata", poolIdBech32)

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata]("io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata", r)
          case r if r.status.code == 404 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.GenericError]("io.gimbalabs.hilltop.api.v0.models.GenericError", r).flatMap(body => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }
    }

    object Stakepools extends Stakepools[F] {
      override def getVrfVkeyByVrfVkeyHash(
        vrfVkeyHash: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.gimbalabs.hilltop.api.v0.models.Stakepool] = {
        val urlPath = Seq("stakepools", "vrf_vkey", vrfVkeyHash)

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.Stakepool]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.Stakepool]("io.gimbalabs.hilltop.api.v0.models.Stakepool", r)
          case r if r.status.code == 404 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.GenericError]("io.gimbalabs.hilltop.api.v0.models.GenericError", r).flatMap(body => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }

      override def getEstablishedEpochByPoolId(
        poolId: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Int] = {
        val urlPath = Seq("stakepools", poolId, "established_epoch")

        _executeRequest[Unit, Int]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, Int]("Int", r)
          case r if r.status.code == 404 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.GenericError]("io.gimbalabs.hilltop.api.v0.models.GenericError", r).flatMap(body => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }

      override def getLiveStakeByPoolId(
        poolId: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Long] = {
        val urlPath = Seq("stakepools", poolId, "live_stake")

        _executeRequest[Unit, Long]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, Long]("Long", r)
          case r if r.status.code == 404 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.GenericError]("io.gimbalabs.hilltop.api.v0.models.GenericError", r).flatMap(body => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }

      override def getBlocksByPoolId(
        poolId: String,
        epoch: _root_.scala.Option[Int] = None,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Int] = {
        val urlPath = Seq("stakepools", poolId, "blocks")

        val queryParameters = Seq(
          epoch.map("epoch" -> _.toString)
        ).flatten

        _executeRequest[Unit, Int]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, Int]("Int", r)
          case r if r.status.code == 404 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.GenericError]("io.gimbalabs.hilltop.api.v0.models.GenericError", r).flatMap(body => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }

      override def get(
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Seq[io.gimbalabs.hilltop.api.v0.models.Stakepool]] = {
        val urlPath = Seq("stakepools")

        _executeRequest[Unit, Seq[io.gimbalabs.hilltop.api.v0.models.Stakepool]]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, Seq[io.gimbalabs.hilltop.api.v0.models.Stakepool]]("Seq[io.gimbalabs.hilltop.api.v0.models.Stakepool]", r)
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }
    }

    object Transactions extends Transactions[F] {
      override def postHistory(
        transactionHistoryRequest: io.gimbalabs.hilltop.api.v0.models.TransactionHistoryRequest,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Seq[io.gimbalabs.hilltop.api.v0.models.Transaction]] = {
        val urlPath = Seq("transactions", "history")

        val (payload, formPayload) = (Some(transactionHistoryRequest), None)

        _executeRequest[io.gimbalabs.hilltop.api.v0.models.TransactionHistoryRequest, Seq[io.gimbalabs.hilltop.api.v0.models.Transaction]]("POST", path = urlPath, body = payload, formBody = formPayload, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, Seq[io.gimbalabs.hilltop.api.v0.models.Transaction]]("Seq[io.gimbalabs.hilltop.api.v0.models.Transaction]", r)
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }
    }

    object WalletBalances extends WalletBalances[F] {
      override def getByStakingAddress(
        stakingAddress: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.gimbalabs.hilltop.api.v0.models.WalletBalance] = {
        val urlPath = Seq("wallet_balances", stakingAddress)

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.WalletBalance]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[F, io.gimbalabs.hilltop.api.v0.models.WalletBalance]("io.gimbalabs.hilltop.api.v0.models.WalletBalance", r)
          case r => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }
    }

    private lazy val defaultApiHeaders = Seq(
      ("User-Agent", Constants.UserAgent),
      ("X-Apidoc-Version", Constants.Version),
      ("X-Apidoc-Version-Major", Constants.VersionMajor.toString)
    )

    def apiHeaders: Seq[(String, String)] = defaultApiHeaders

    def modifyRequest(request: F[org.http4s.Request[F]]): F[org.http4s.Request[F]] = request

    implicit def circeJsonEncoder[F[_]: Sync, A](implicit encoder: io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[F, A]

    def _executeRequest[T, U](
      method: String,
      path: Seq[String],
      queryParameters: Seq[(String, String)] = Nil,
      requestHeaders: Seq[(String, String)] = Nil,
      body: Option[T] = None,
      formBody : Option[org.http4s.UrlForm] = None
    )(handler: org.http4s.Response[F] => F[U]
    )(implicit encoder: io.circe.Encoder[T]): F[U] = {
      import org.http4s.QueryParamEncoder._

      val m = org.http4s.Method.fromString(method) match {
        case Right(m) => m
        case Left(e) => sys.error(e.toString)
      }

      val headers = org.http4s.Headers((
        apiHeaders ++
        defaultHeaders ++
        requestHeaders
      ).groupBy(_._1).map { case (k, l) => org.http4s.Header(k, l.last._2) }.toList)

      val queryMap = queryParameters.groupBy(_._1).map { case (k, v) => k -> v.map(_._2) }
      val uri = path.foldLeft(baseUrl){ case (uri, segment) => uri / segment }.setQueryParams(queryMap)

      val request = org.http4s.Request[F](method = m,
                                       uri = uri,
                                       headers = headers)

      val reqAndMaybeAuth = auth.fold(request) {
        case Authorization.Basic(username, passwordOpt) => {
          val userpass = s"$username:${passwordOpt.getOrElse("")}"
          val token = java.util.Base64.getEncoder.encodeToString(userpass.getBytes(java.nio.charset.StandardCharsets.ISO_8859_1))
          request.putHeaders(org.http4s.Header("Authorization", s"Basic $token"))
        }
        case a => sys.error("Invalid authorization scheme[" + a.getClass + "]")
      }

      val reqAndMaybeAuthAndBody =
        if (formBody.nonEmpty) formBody.fold(Sync[F].pure(reqAndMaybeAuth))(reqAndMaybeAuth.withBody)
        else body.fold(Sync[F].pure(reqAndMaybeAuth))(reqAndMaybeAuth.withBody)

      httpClient.fetch(modifyRequest(reqAndMaybeAuthAndBody))(handler)
    }
  }

  object Client {
    import cats.effect._

    implicit def circeJsonDecoder[F[_]: Sync, A](implicit decoder: io.circe.Decoder[A]) = org.http4s.circe.jsonOf[F, A]

    def parseJson[F[_]: Sync, T](
      className: String,
      r: org.http4s.Response[F]
    )(implicit decoder: io.circe.Decoder[T]): F[T] = r.attemptAs[T].value.flatMap {
      case Right(value) => Sync[F].pure(value)
      case Left(error) => Sync[F].raiseError(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Invalid json for class[" + className + "]", None, error))
    }
  }

  sealed trait Authorization extends _root_.scala.Product with _root_.scala.Serializable
  object Authorization {
    final case class Basic(username: String, password: Option[String] = None) extends Authorization
  }

  package interfaces {

    trait Client[F[_]] {
      def baseUrl: org.http4s.Uri
      def activeStakeAmounts: io.gimbalabs.hilltop.api.v0.ActiveStakeAmounts[F]
      def blocks: io.gimbalabs.hilltop.api.v0.Blocks[F]
      def delegations: io.gimbalabs.hilltop.api.v0.Delegations[F]
      def delegatorsCounts: io.gimbalabs.hilltop.api.v0.DelegatorsCounts[F]
      def epochs: io.gimbalabs.hilltop.api.v0.Epochs[F]
      def healthchecks: io.gimbalabs.hilltop.api.v0.Healthchecks[F]
      def nativeAssets: io.gimbalabs.hilltop.api.v0.NativeAssets[F]
      def poolUpdates: io.gimbalabs.hilltop.api.v0.PoolUpdates[F]
      def rewards: io.gimbalabs.hilltop.api.v0.Rewards[F]
      def sigmas: io.gimbalabs.hilltop.api.v0.Sigmas[F]
      def stakepoolMetadata: io.gimbalabs.hilltop.api.v0.StakepoolMetadata[F]
      def stakepools: io.gimbalabs.hilltop.api.v0.Stakepools[F]
      def transactions: io.gimbalabs.hilltop.api.v0.Transactions[F]
      def walletBalances: io.gimbalabs.hilltop.api.v0.WalletBalances[F]
    }

  }

  trait ActiveStakeAmounts[F[_]] {
    def get(
      epochNumber: _root_.scala.Option[Int] = None,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount]

    def getByPoolBech32Id(
      poolBech32Id: String,
      epochNumber: _root_.scala.Option[Int] = None,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount]

    def getAddressesByPoolBech32Id(
      poolBech32Id: String,
      epochNumber: Int,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Seq[io.gimbalabs.hilltop.api.v0.models.AddressStakeAmount]]
  }

  trait Blocks[F[_]] {
    def getBlocksInDay(
      date: _root_.java.time.LocalDate,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.gimbalabs.hilltop.api.v0.models.DayBlock]

    /**
     * @param blockNumber the block number
     */
    def getByBlockNumber(
      blockNumber: Long,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.gimbalabs.hilltop.api.v0.models.Block]
  }

  trait Delegations[F[_]] {
    def getSafePaymentByStakingAddress(
      stakingAddress: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[String]

    def getStakepoolByStakingAddress(
      stakingAddress: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.gimbalabs.hilltop.api.v0.models.Delegation]
  }

  trait DelegatorsCounts[F[_]] {
    def getByPoolBech32Id(
      poolBech32Id: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.gimbalabs.hilltop.api.v0.models.DelegatorsCount]
  }

  trait Epochs[F[_]] {
    def getCurrent(
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.gimbalabs.hilltop.api.v0.models.Epoch]

    def getByEpochNumber(
      epochNumber: Int,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.gimbalabs.hilltop.api.v0.models.Epoch]
  }

  trait Healthchecks[F[_]] {
    def get(
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.gimbalabs.hilltop.api.v0.models.Healthcheck]
  }

  trait NativeAssets[F[_]] {
    /**
     * @param blockNumberFrom the block number from when fetching updates, it's the pagination index
     * @param limit the number of updates to fetch
     */
    def getIds(
      blockNumberFrom: _root_.scala.Option[Long] = None,
      limit: _root_.scala.Option[Long] = None,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetId]]

    /**
     * @param policyId the policy id to get the asset name
     */
    def getAssetNamesByPolicyId(
      policyId: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Seq[String]]

    def getNfts(
      blockNumberFrom: Long,
      blockNumberTo: Long,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Seq[io.gimbalabs.hilltop.api.v0.models.NftDetails]]

    def postNativeAssetsDetails(
      nativeAssetDetailsRequest: io.gimbalabs.hilltop.api.v0.models.NativeAssetDetailsRequest,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetDetails]]

    def getByStakeAddress(
      stakeAddress: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Seq[io.gimbalabs.hilltop.api.v0.models.NativeAsset]]
  }

  trait PoolUpdates[F[_]] {
    /**
     * @param blockNumberFrom the block number from when fetching updates, it's the pagination index
     * @param limit the number of updates to fetch
     */
    def getRetiring(
      blockNumberFrom: _root_.scala.Option[Long] = None,
      limit: _root_.scala.Option[Long] = None,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Seq[io.gimbalabs.hilltop.api.v0.models.PoolRetiring]]

    /**
     * @param blockNumberFrom the block number from when fetching updates, it's the pagination index
     * @param limit the number of updates to fetch
     */
    def getByPoolId(
      poolId: String,
      blockNumberFrom: _root_.scala.Option[Long] = None,
      limit: _root_.scala.Option[Long] = None,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]]

    /**
     * @param blockNumberFrom the block number from when fetching updates, it's the pagination index
     * @param limit the number of updates to fetch
     */
    def get(
      blockNumberFrom: _root_.scala.Option[Long] = None,
      limit: _root_.scala.Option[Long] = None,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]]
  }

  trait Rewards[F[_]] {
    def getByStakingAddress(
      stakingAddress: String,
      epochFrom: _root_.scala.Option[Int] = None,
      epochTo: _root_.scala.Option[Int] = None,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Seq[io.gimbalabs.hilltop.api.v0.models.Reward]]
  }

  trait Sigmas[F[_]] {
    /**
     * can be either the pool_id (e.g. pool1wcwe923r...) or the pool_hash
     */
    def getByPoolId(
      poolId: String,
      epochNumber: Int,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.gimbalabs.hilltop.api.v0.models.Sigma]
  }

  trait StakepoolMetadata[F[_]] {
    def getByPoolIdBech32(
      poolIdBech32: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata]
  }

  trait Stakepools[F[_]] {
    /**
     * find pool details by vrf_vkey
     *
     * @param vrfVkeyHash the hash of the vrf_vkey
     */
    def getVrfVkeyByVrfVkeyHash(
      vrfVkeyHash: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.gimbalabs.hilltop.api.v0.models.Stakepool]

    /**
     * Epoch at which stake pool was originally registered
     *
     * @param poolId id of the pool to query. Both id and bech32 formats are supported
     */
    def getEstablishedEpochByPoolId(
      poolId: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Int]

    /**
     * live stake in lovelaces
     *
     * @param poolId id of the pool to query. Both id and bech32 formats are supported
     */
    def getLiveStakeByPoolId(
      poolId: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Long]

    /**
     * number minted blocks in epoch
     *
     * @param poolId id of the pool to query. Both id and bech32 formats are supported
     * @param epoch epoch in which to query number of produced blocks or current epoch if not
     *        specified
     */
    def getBlocksByPoolId(
      poolId: String,
      epoch: _root_.scala.Option[Int] = None,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Int]

    def get(
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Seq[io.gimbalabs.hilltop.api.v0.models.Stakepool]]
  }

  trait Transactions[F[_]] {
    def postHistory(
      transactionHistoryRequest: io.gimbalabs.hilltop.api.v0.models.TransactionHistoryRequest,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Seq[io.gimbalabs.hilltop.api.v0.models.Transaction]]
  }

  trait WalletBalances[F[_]] {
    def getByStakingAddress(
      stakingAddress: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.gimbalabs.hilltop.api.v0.models.WalletBalance]
  }

  package errors {

    final case class GenericErrorResponse(
      headers: org.http4s.Headers,
      status: Int,
      message: Option[String] = None,
      body: io.gimbalabs.hilltop.api.v0.models.GenericError
    ) extends Exception(s"HTTP $status${message.fold("")(m => s": $m")}"){
      lazy val genericError = body
    }

    final case class FailedRequest(responseCode: Int, message: String, requestUri: Option[_root_.java.net.URI] = None, parent: Exception = null) extends _root_.java.lang.Exception(s"HTTP $responseCode: $message", parent)

  }
}