/**
 * 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/play_2_8_client
 */
package io.gimbalabs.hilltop.api.v0.models {

  final case class ActiveStakeAmount(
    amountInLovelaces: Long
  )

  /**
   * @param stakeAddress stake1...
   */

  final case class AddressStakeAmount(
    stakeAddress: String,
    amountInLovelaces: Long
  )

  final case class Block(
    number: Long,
    epochNumber: Long,
    slotNumber: Long,
    epochSlotNumber: Long,
    size: Long,
    transactionCount: Long,
    time: _root_.org.joda.time.DateTime
  )

  final case class CnftMetadataV001(
    policyId: String,
    tokens: Map[String, String],
    asset: io.gimbalabs.hilltop.api.v0.models.CnftMetadataV001Asset
  )

  final case class CnftMetadataV001Asset(
    assetName: _root_.scala.Option[String] = None,
    attributes: _root_.scala.Option[_root_.play.api.libs.json.JsValue] = None,
    ipfs: String,
    mimeType: _root_.scala.Option[String] = None
  )

  final case class DayBlock(
    first: io.gimbalabs.hilltop.api.v0.models.Block,
    last: io.gimbalabs.hilltop.api.v0.models.Block
  )

  final case class Delegation(
    stakingAddress: String,
    delegations: Seq[io.gimbalabs.hilltop.api.v0.models.StakepoolDelegation]
  )

  final case class DelegatorsCount(
    delegatorsCountTotal: Int
  )

  final case class Epoch(
    outSum: Long,
    fees: Long,
    txCount: Int,
    blkCount: Int,
    number: Int,
    startTime: _root_.org.joda.time.DateTime,
    endTime: _root_.org.joda.time.DateTime
  )

  final case class GenericError(
    description: String
  )

  /**
   * Response for the healthcheck's endpoint of the service
   */

  final case class Healthcheck(
    status: String
  )

  final case class NativeAsset(
    transactionId: String,
    policyId: String,
    tokenName: String,
    metadata: _root_.play.api.libs.json.JsValue,
    blockNumber: Long,
    epochSlotNumber: Long,
    epochNumber: Long,
    invalidBefore: _root_.scala.Option[Long] = None,
    invalidHereafter: _root_.scala.Option[Long] = None,
    quantity: Long
  )

  final case class NativeAssetDetails(
    policyId: String,
    assetName: String,
    metadata: _root_.play.api.libs.json.JsValue,
    mintedAt: _root_.org.joda.time.DateTime,
    lastMintedAt: _root_.org.joda.time.DateTime,
    firstMintingTxBlock: Long,
    lastMintingTxBlock: Long,
    mintingTxHash: String,
    circulatingSupply: Long,
    fingerprint: String
  )

  final case class NativeAssetDetailsRequest(
    policyId: String,
    assetNames: _root_.scala.Option[Seq[String]] = None
  )

  final case class NativeAssetId(
    policyId: String,
    assetName: String,
    blockNumber: Long,
    blockTime: _root_.org.joda.time.DateTime,
    fingerprint: String
  )

  final case class NftDetails(
    policyId: String,
    assetNameRaw: String,
    assetName: _root_.scala.Option[String] = None,
    metadata: _root_.play.api.libs.json.JsValue,
    mintedAt: _root_.org.joda.time.DateTime,
    mintedAtBlock: Long,
    mintingTxHash: String,
    amount: Long,
    fingerprint: String
  )

  final case class NftMetadata(
    name: _root_.scala.Option[String] = None,
    image: _root_.scala.Option[String] = None,
    mediaType: _root_.scala.Option[String] = None,
    files: _root_.scala.Option[Seq[io.gimbalabs.hilltop.api.v0.models.NftMetadataFile]] = None
  )

  final case class NftMetadataFile(
    name: _root_.scala.Option[String] = None,
    src: _root_.scala.Option[String] = None,
    mediaType: _root_.scala.Option[String] = None
  )

  final case class NftMetadataFilesAsObject(
    name: _root_.scala.Option[String] = None,
    image: _root_.scala.Option[String] = None,
    mediaType: _root_.scala.Option[String] = None,
    files: _root_.scala.Option[io.gimbalabs.hilltop.api.v0.models.NftMetadataFile] = None
  )

  final case class NftMetadataImgArray(
    name: _root_.scala.Option[String] = None,
    image: _root_.scala.Option[Seq[String]] = None,
    mediaType: _root_.scala.Option[String] = None,
    files: _root_.scala.Option[Seq[io.gimbalabs.hilltop.api.v0.models.NftMetadataFile]] = None
  )

  final case class NftMetadataNoFiles(
    name: _root_.scala.Option[String] = None,
    image: _root_.scala.Option[String] = None,
    mediaType: _root_.scala.Option[String] = None
  )

  final case class PoolRetiring(
    tickerName: _root_.scala.Option[String] = None,
    poolId: String,
    certificateIndex: Int,
    epochNumber: Long,
    blockNumber: Long,
    retiringAtEpoch: Long,
    txHash: String
  )

  final case class PoolUpdate(
    epochNumber: Int,
    blockNumber: Long,
    txHash: String,
    poolTickerName: _root_.scala.Option[String] = None,
    poolBech32Id: String,
    certificateIndex: Int,
    vrfKeyHash: String,
    pledge: Long,
    rewardAddress: String,
    activeEpochNumber: Long,
    margin: Double,
    fixedCost: Long
  )

  final case class Reward(
    stakingAddress: String,
    epoch: Int,
    amount: Long,
    poolId: String
  )

  final case class Sigma(
    sigma: Double,
    epoch: Int,
    totalStaked: Long,
    activeStake: Long,
    nonce: String,
    d: Double
  )

  /**
   * @param id the id of the pool
   * @param poolIdBech32 the id in bech32 format of the pool
   * @param cost operational costs per epoch in lovelaces
   * @param margin operator margin, percentage (from 0 to 1)
   * @param pledge pledge amount, in lovelaces
   * @param activeStake active stake for current epoch in lovelaces
   * @param saturation pool saturation as percentage (0 to 1)
   * @param retiringAtEpoch if defined, is the epoch at which the pool will retire
   */

  final case class Stakepool(
    id: String,
    poolIdBech32: String,
    metadata: _root_.scala.Option[io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata] = None,
    cost: Long,
    margin: Double,
    pledge: Long,
    activeStake: Long,
    saturation: Double,
    retiringAtEpoch: _root_.scala.Option[Long] = None
  )

  final case class StakepoolDelegation(
    stakepool: io.gimbalabs.hilltop.api.v0.models.Stakepool,
    epoch: Int
  )

  /**
   * Stake Pool Offline Metadata
   */

  final case class StakepoolMetadata(
    name: String,
    ticker: String,
    homepage: String,
    description: String,
    extended: _root_.scala.Option[String] = None
  )

  final case class Transaction(
    hash: String,
    block: Long,
    timestamp: _root_.org.joda.time.DateTime
  )

  final case class TransactionHistoryRequest(
    addresses: Seq[String]
  )

  final case class WalletBalance(
    balance: Long
  )
  sealed trait Country extends _root_.scala.Product with _root_.scala.Serializable

  object Country {

    case object Ie extends Country { override def toString = "IE" }
    case object Uk extends Country { override def toString = "UK" }
    /**
     * UNDEFINED captures values that are sent either in error or
     * that were added by the server after this library was
     * generated. We want to make it easy and obvious to users of
     * this library to handle this case gracefully.
     *
     * We use all CAPS for the variable name to avoid collisions
     * with the camel cased values above.
     */
    final case class UNDEFINED(override val toString: String) extends Country

    /**
     * all returns a list of all the valid, known values. We use
     * lower case to avoid collisions with the camel cased values
     * above.
     */
    val all: scala.List[Country] = scala.List(Ie, Uk)

    private
    val byName: Map[String, Country] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): Country = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[Country] = byName.get(value.toLowerCase)

  }

}

package io.gimbalabs.hilltop.api.v0.models {

  package object json {
    import play.api.libs.json.__
    import play.api.libs.json.JsString
    import play.api.libs.json.Writes
    import play.api.libs.functional.syntax._
    import io.gimbalabs.hilltop.api.v0.models.json._

    private[v0] implicit val jsonReadsUUID: play.api.libs.json.Reads[_root_.java.util.UUID] = __.read[String].map { str =>
      _root_.java.util.UUID.fromString(str)
    }

    private[v0] implicit val jsonWritesUUID: play.api.libs.json.Writes[_root_.java.util.UUID] = (x: _root_.java.util.UUID) => play.api.libs.json.JsString(x.toString)

    private[v0] implicit val jsonReadsJodaDateTime: play.api.libs.json.Reads[_root_.org.joda.time.DateTime] = __.read[String].map { str =>
      _root_.org.joda.time.format.ISODateTimeFormat.dateTimeParser.parseDateTime(str)
    }

    private[v0] implicit val jsonWritesJodaDateTime: play.api.libs.json.Writes[_root_.org.joda.time.DateTime] = (x: _root_.org.joda.time.DateTime) => {
      play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.dateTime.print(x))
    }

    private[v0] implicit val jsonReadsJodaLocalDate: play.api.libs.json.Reads[_root_.org.joda.time.LocalDate] = __.read[String].map { str =>
      _root_.org.joda.time.format.ISODateTimeFormat.dateTimeParser.parseLocalDate(str)
    }

    private[v0] implicit val jsonWritesJodaLocalDate: play.api.libs.json.Writes[_root_.org.joda.time.LocalDate] = (x: _root_.org.joda.time.LocalDate) => {
      play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.date.print(x))
    }

    implicit val jsonReadsHilltopApiCountry: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.Country] = new play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.Country] {
      def reads(js: play.api.libs.json.JsValue): play.api.libs.json.JsResult[io.gimbalabs.hilltop.api.v0.models.Country] = {
        js match {
          case v: play.api.libs.json.JsString => play.api.libs.json.JsSuccess(io.gimbalabs.hilltop.api.v0.models.Country(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.gimbalabs.hilltop.api.v0.models.Country(v))
              case _: play.api.libs.json.JsError =>
                (js \ "country").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.gimbalabs.hilltop.api.v0.models.Country(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

    def jsonWritesHilltopApiCountry(obj: io.gimbalabs.hilltop.api.v0.models.Country) = {
      play.api.libs.json.JsString(obj.toString)
    }

    def jsObjectCountry(obj: io.gimbalabs.hilltop.api.v0.models.Country) = {
      play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
    }

    implicit def jsonWritesHilltopApiCountry: play.api.libs.json.Writes[Country] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.Country) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsonWritesHilltopApiCountry(obj)
      }
    }

    implicit def jsonReadsHilltopApiActiveStakeAmount: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount] = {
      (__ \ "amount_in_lovelaces").read[Long].map { x => ActiveStakeAmount(amountInLovelaces = x) }
    }

    def jsObjectActiveStakeAmount(obj: io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "amount_in_lovelaces" -> play.api.libs.json.JsNumber(obj.amountInLovelaces)
      )
    }

    implicit def jsonWritesHilltopApiActiveStakeAmount: play.api.libs.json.Writes[ActiveStakeAmount] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectActiveStakeAmount(obj)
      }
    }

    implicit def jsonReadsHilltopApiAddressStakeAmount: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.AddressStakeAmount] = {
      for {
        stakeAddress <- (__ \ "stake_address").read[String]
        amountInLovelaces <- (__ \ "amount_in_lovelaces").read[Long]
      } yield AddressStakeAmount(stakeAddress, amountInLovelaces)
    }

    def jsObjectAddressStakeAmount(obj: io.gimbalabs.hilltop.api.v0.models.AddressStakeAmount): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "stake_address" -> play.api.libs.json.JsString(obj.stakeAddress),
        "amount_in_lovelaces" -> play.api.libs.json.JsNumber(obj.amountInLovelaces)
      )
    }

    implicit def jsonWritesHilltopApiAddressStakeAmount: play.api.libs.json.Writes[AddressStakeAmount] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.AddressStakeAmount) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectAddressStakeAmount(obj)
      }
    }

    implicit def jsonReadsHilltopApiBlock: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.Block] = {
      for {
        number <- (__ \ "number").read[Long]
        epochNumber <- (__ \ "epoch_number").read[Long]
        slotNumber <- (__ \ "slot_number").read[Long]
        epochSlotNumber <- (__ \ "epoch_slot_number").read[Long]
        size <- (__ \ "size").read[Long]
        transactionCount <- (__ \ "transaction_count").read[Long]
        time <- (__ \ "time").read[_root_.org.joda.time.DateTime]
      } yield Block(number, epochNumber, slotNumber, epochSlotNumber, size, transactionCount, time)
    }

    def jsObjectBlock(obj: io.gimbalabs.hilltop.api.v0.models.Block): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "number" -> play.api.libs.json.JsNumber(obj.number),
        "epoch_number" -> play.api.libs.json.JsNumber(obj.epochNumber),
        "slot_number" -> play.api.libs.json.JsNumber(obj.slotNumber),
        "epoch_slot_number" -> play.api.libs.json.JsNumber(obj.epochSlotNumber),
        "size" -> play.api.libs.json.JsNumber(obj.size),
        "transaction_count" -> play.api.libs.json.JsNumber(obj.transactionCount),
        "time" -> play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.dateTime.print(obj.time))
      )
    }

    implicit def jsonWritesHilltopApiBlock: play.api.libs.json.Writes[Block] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.Block) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectBlock(obj)
      }
    }

    implicit def jsonReadsHilltopApiCnftMetadataV001: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.CnftMetadataV001] = {
      for {
        policyId <- (__ \ "policyId").read[String]
        tokens <- (__ \ "tokens").read[Map[String, String]]
        asset <- (__ \ "asset").read[io.gimbalabs.hilltop.api.v0.models.CnftMetadataV001Asset]
      } yield CnftMetadataV001(policyId, tokens, asset)
    }

    def jsObjectCnftMetadataV001(obj: io.gimbalabs.hilltop.api.v0.models.CnftMetadataV001): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "policyId" -> play.api.libs.json.JsString(obj.policyId),
        "tokens" -> play.api.libs.json.Json.toJson(obj.tokens),
        "asset" -> io.gimbalabs.hilltop.api.v0.models.json.jsObjectCnftMetadataV001Asset(obj.asset)
      )
    }

    implicit def jsonWritesHilltopApiCnftMetadataV001: play.api.libs.json.Writes[CnftMetadataV001] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.CnftMetadataV001) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectCnftMetadataV001(obj)
      }
    }

    implicit def jsonReadsHilltopApiCnftMetadataV001Asset: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.CnftMetadataV001Asset] = {
      for {
        assetName <- (__ \ "assetName").readNullable[String]
        attributes <- (__ \ "attributes").readNullable[_root_.play.api.libs.json.JsValue]
        ipfs <- (__ \ "ipfs").read[String]
        mimeType <- (__ \ "mimeType").readNullable[String]
      } yield CnftMetadataV001Asset(assetName, attributes, ipfs, mimeType)
    }

    def jsObjectCnftMetadataV001Asset(obj: io.gimbalabs.hilltop.api.v0.models.CnftMetadataV001Asset): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "ipfs" -> play.api.libs.json.JsString(obj.ipfs)
      ) ++ (obj.assetName match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("assetName" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.attributes match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("attributes" -> x)
      }) ++
      (obj.mimeType match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("mimeType" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesHilltopApiCnftMetadataV001Asset: play.api.libs.json.Writes[CnftMetadataV001Asset] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.CnftMetadataV001Asset) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectCnftMetadataV001Asset(obj)
      }
    }

    implicit def jsonReadsHilltopApiDayBlock: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.DayBlock] = {
      for {
        first <- (__ \ "first").read[io.gimbalabs.hilltop.api.v0.models.Block]
        last <- (__ \ "last").read[io.gimbalabs.hilltop.api.v0.models.Block]
      } yield DayBlock(first, last)
    }

    def jsObjectDayBlock(obj: io.gimbalabs.hilltop.api.v0.models.DayBlock): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "first" -> io.gimbalabs.hilltop.api.v0.models.json.jsObjectBlock(obj.first),
        "last" -> io.gimbalabs.hilltop.api.v0.models.json.jsObjectBlock(obj.last)
      )
    }

    implicit def jsonWritesHilltopApiDayBlock: play.api.libs.json.Writes[DayBlock] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.DayBlock) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectDayBlock(obj)
      }
    }

    implicit def jsonReadsHilltopApiDelegation: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.Delegation] = {
      for {
        stakingAddress <- (__ \ "staking_address").read[String]
        delegations <- (__ \ "delegations").read[Seq[io.gimbalabs.hilltop.api.v0.models.StakepoolDelegation]]
      } yield Delegation(stakingAddress, delegations)
    }

    def jsObjectDelegation(obj: io.gimbalabs.hilltop.api.v0.models.Delegation): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "staking_address" -> play.api.libs.json.JsString(obj.stakingAddress),
        "delegations" -> play.api.libs.json.Json.toJson(obj.delegations)
      )
    }

    implicit def jsonWritesHilltopApiDelegation: play.api.libs.json.Writes[Delegation] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.Delegation) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectDelegation(obj)
      }
    }

    implicit def jsonReadsHilltopApiDelegatorsCount: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.DelegatorsCount] = {
      (__ \ "delegators_count_total").read[Int].map { x => DelegatorsCount(delegatorsCountTotal = x) }
    }

    def jsObjectDelegatorsCount(obj: io.gimbalabs.hilltop.api.v0.models.DelegatorsCount): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "delegators_count_total" -> play.api.libs.json.JsNumber(obj.delegatorsCountTotal)
      )
    }

    implicit def jsonWritesHilltopApiDelegatorsCount: play.api.libs.json.Writes[DelegatorsCount] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.DelegatorsCount) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectDelegatorsCount(obj)
      }
    }

    implicit def jsonReadsHilltopApiEpoch: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.Epoch] = {
      for {
        outSum <- (__ \ "out_sum").read[Long]
        fees <- (__ \ "fees").read[Long]
        txCount <- (__ \ "tx_count").read[Int]
        blkCount <- (__ \ "blk_count").read[Int]
        number <- (__ \ "number").read[Int]
        startTime <- (__ \ "start_time").read[_root_.org.joda.time.DateTime]
        endTime <- (__ \ "end_time").read[_root_.org.joda.time.DateTime]
      } yield Epoch(outSum, fees, txCount, blkCount, number, startTime, endTime)
    }

    def jsObjectEpoch(obj: io.gimbalabs.hilltop.api.v0.models.Epoch): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "out_sum" -> play.api.libs.json.JsNumber(obj.outSum),
        "fees" -> play.api.libs.json.JsNumber(obj.fees),
        "tx_count" -> play.api.libs.json.JsNumber(obj.txCount),
        "blk_count" -> play.api.libs.json.JsNumber(obj.blkCount),
        "number" -> play.api.libs.json.JsNumber(obj.number),
        "start_time" -> play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.dateTime.print(obj.startTime)),
        "end_time" -> play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.dateTime.print(obj.endTime))
      )
    }

    implicit def jsonWritesHilltopApiEpoch: play.api.libs.json.Writes[Epoch] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.Epoch) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectEpoch(obj)
      }
    }

    implicit def jsonReadsHilltopApiGenericError: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.GenericError] = {
      (__ \ "description").read[String].map { x => GenericError(description = x) }
    }

    def jsObjectGenericError(obj: io.gimbalabs.hilltop.api.v0.models.GenericError): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "description" -> play.api.libs.json.JsString(obj.description)
      )
    }

    implicit def jsonWritesHilltopApiGenericError: play.api.libs.json.Writes[GenericError] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.GenericError) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectGenericError(obj)
      }
    }

    implicit def jsonReadsHilltopApiHealthcheck: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.Healthcheck] = {
      (__ \ "status").read[String].map { x => Healthcheck(status = x) }
    }

    def jsObjectHealthcheck(obj: io.gimbalabs.hilltop.api.v0.models.Healthcheck): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "status" -> play.api.libs.json.JsString(obj.status)
      )
    }

    implicit def jsonWritesHilltopApiHealthcheck: play.api.libs.json.Writes[Healthcheck] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.Healthcheck) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectHealthcheck(obj)
      }
    }

    implicit def jsonReadsHilltopApiNativeAsset: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.NativeAsset] = {
      for {
        transactionId <- (__ \ "transaction_id").read[String]
        policyId <- (__ \ "policy_id").read[String]
        tokenName <- (__ \ "token_name").read[String]
        metadata <- (__ \ "metadata").read[_root_.play.api.libs.json.JsValue]
        blockNumber <- (__ \ "block_number").read[Long]
        epochSlotNumber <- (__ \ "epoch_slot_number").read[Long]
        epochNumber <- (__ \ "epoch_number").read[Long]
        invalidBefore <- (__ \ "invalid_before").readNullable[Long]
        invalidHereafter <- (__ \ "invalid_hereafter").readNullable[Long]
        quantity <- (__ \ "quantity").read[Long]
      } yield NativeAsset(transactionId, policyId, tokenName, metadata, blockNumber, epochSlotNumber, epochNumber, invalidBefore, invalidHereafter, quantity)
    }

    def jsObjectNativeAsset(obj: io.gimbalabs.hilltop.api.v0.models.NativeAsset): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "transaction_id" -> play.api.libs.json.JsString(obj.transactionId),
        "policy_id" -> play.api.libs.json.JsString(obj.policyId),
        "token_name" -> play.api.libs.json.JsString(obj.tokenName),
        "metadata" -> obj.metadata,
        "block_number" -> play.api.libs.json.JsNumber(obj.blockNumber),
        "epoch_slot_number" -> play.api.libs.json.JsNumber(obj.epochSlotNumber),
        "epoch_number" -> play.api.libs.json.JsNumber(obj.epochNumber),
        "quantity" -> play.api.libs.json.JsNumber(obj.quantity)
      ) ++ (obj.invalidBefore match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("invalid_before" -> play.api.libs.json.JsNumber(x))
      }) ++
      (obj.invalidHereafter match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("invalid_hereafter" -> play.api.libs.json.JsNumber(x))
      })
    }

    implicit def jsonWritesHilltopApiNativeAsset: play.api.libs.json.Writes[NativeAsset] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.NativeAsset) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectNativeAsset(obj)
      }
    }

    implicit def jsonReadsHilltopApiNativeAssetDetails: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.NativeAssetDetails] = {
      for {
        policyId <- (__ \ "policy_id").read[String]
        assetName <- (__ \ "asset_name").read[String]
        metadata <- (__ \ "metadata").read[_root_.play.api.libs.json.JsValue]
        mintedAt <- (__ \ "minted_at").read[_root_.org.joda.time.DateTime]
        lastMintedAt <- (__ \ "last_minted_at").read[_root_.org.joda.time.DateTime]
        firstMintingTxBlock <- (__ \ "first_minting_tx_block").read[Long]
        lastMintingTxBlock <- (__ \ "last_minting_tx_block").read[Long]
        mintingTxHash <- (__ \ "minting_tx_hash").read[String]
        circulatingSupply <- (__ \ "circulating_supply").read[Long]
        fingerprint <- (__ \ "fingerprint").read[String]
      } yield NativeAssetDetails(policyId, assetName, metadata, mintedAt, lastMintedAt, firstMintingTxBlock, lastMintingTxBlock, mintingTxHash, circulatingSupply, fingerprint)
    }

    def jsObjectNativeAssetDetails(obj: io.gimbalabs.hilltop.api.v0.models.NativeAssetDetails): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "policy_id" -> play.api.libs.json.JsString(obj.policyId),
        "asset_name" -> play.api.libs.json.JsString(obj.assetName),
        "metadata" -> obj.metadata,
        "minted_at" -> play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.dateTime.print(obj.mintedAt)),
        "last_minted_at" -> play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.dateTime.print(obj.lastMintedAt)),
        "first_minting_tx_block" -> play.api.libs.json.JsNumber(obj.firstMintingTxBlock),
        "last_minting_tx_block" -> play.api.libs.json.JsNumber(obj.lastMintingTxBlock),
        "minting_tx_hash" -> play.api.libs.json.JsString(obj.mintingTxHash),
        "circulating_supply" -> play.api.libs.json.JsNumber(obj.circulatingSupply),
        "fingerprint" -> play.api.libs.json.JsString(obj.fingerprint)
      )
    }

    implicit def jsonWritesHilltopApiNativeAssetDetails: play.api.libs.json.Writes[NativeAssetDetails] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.NativeAssetDetails) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectNativeAssetDetails(obj)
      }
    }

    implicit def jsonReadsHilltopApiNativeAssetDetailsRequest: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.NativeAssetDetailsRequest] = {
      for {
        policyId <- (__ \ "policy_id").read[String]
        assetNames <- (__ \ "asset_names").readNullable[Seq[String]]
      } yield NativeAssetDetailsRequest(policyId, assetNames)
    }

    def jsObjectNativeAssetDetailsRequest(obj: io.gimbalabs.hilltop.api.v0.models.NativeAssetDetailsRequest): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "policy_id" -> play.api.libs.json.JsString(obj.policyId)
      ) ++ (obj.assetNames match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("asset_names" -> play.api.libs.json.Json.toJson(x))
      })
    }

    implicit def jsonWritesHilltopApiNativeAssetDetailsRequest: play.api.libs.json.Writes[NativeAssetDetailsRequest] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.NativeAssetDetailsRequest) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectNativeAssetDetailsRequest(obj)
      }
    }

    implicit def jsonReadsHilltopApiNativeAssetId: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.NativeAssetId] = {
      for {
        policyId <- (__ \ "policy_id").read[String]
        assetName <- (__ \ "asset_name").read[String]
        blockNumber <- (__ \ "block_number").read[Long]
        blockTime <- (__ \ "block_time").read[_root_.org.joda.time.DateTime]
        fingerprint <- (__ \ "fingerprint").read[String]
      } yield NativeAssetId(policyId, assetName, blockNumber, blockTime, fingerprint)
    }

    def jsObjectNativeAssetId(obj: io.gimbalabs.hilltop.api.v0.models.NativeAssetId): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "policy_id" -> play.api.libs.json.JsString(obj.policyId),
        "asset_name" -> play.api.libs.json.JsString(obj.assetName),
        "block_number" -> play.api.libs.json.JsNumber(obj.blockNumber),
        "block_time" -> play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.dateTime.print(obj.blockTime)),
        "fingerprint" -> play.api.libs.json.JsString(obj.fingerprint)
      )
    }

    implicit def jsonWritesHilltopApiNativeAssetId: play.api.libs.json.Writes[NativeAssetId] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.NativeAssetId) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectNativeAssetId(obj)
      }
    }

    implicit def jsonReadsHilltopApiNftDetails: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.NftDetails] = {
      for {
        policyId <- (__ \ "policy_id").read[String]
        assetNameRaw <- (__ \ "asset_name_raw").read[String]
        assetName <- (__ \ "asset_name").readNullable[String]
        metadata <- (__ \ "metadata").read[_root_.play.api.libs.json.JsValue]
        mintedAt <- (__ \ "minted_at").read[_root_.org.joda.time.DateTime]
        mintedAtBlock <- (__ \ "minted_at_block").read[Long]
        mintingTxHash <- (__ \ "minting_tx_hash").read[String]
        amount <- (__ \ "amount").read[Long]
        fingerprint <- (__ \ "fingerprint").read[String]
      } yield NftDetails(policyId, assetNameRaw, assetName, metadata, mintedAt, mintedAtBlock, mintingTxHash, amount, fingerprint)
    }

    def jsObjectNftDetails(obj: io.gimbalabs.hilltop.api.v0.models.NftDetails): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "policy_id" -> play.api.libs.json.JsString(obj.policyId),
        "asset_name_raw" -> play.api.libs.json.JsString(obj.assetNameRaw),
        "metadata" -> obj.metadata,
        "minted_at" -> play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.dateTime.print(obj.mintedAt)),
        "minted_at_block" -> play.api.libs.json.JsNumber(obj.mintedAtBlock),
        "minting_tx_hash" -> play.api.libs.json.JsString(obj.mintingTxHash),
        "amount" -> play.api.libs.json.JsNumber(obj.amount),
        "fingerprint" -> play.api.libs.json.JsString(obj.fingerprint)
      ) ++ (obj.assetName match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("asset_name" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesHilltopApiNftDetails: play.api.libs.json.Writes[NftDetails] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.NftDetails) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectNftDetails(obj)
      }
    }

    implicit def jsonReadsHilltopApiNftMetadata: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.NftMetadata] = {
      for {
        name <- (__ \ "name").readNullable[String]
        image <- (__ \ "image").readNullable[String]
        mediaType <- (__ \ "mediaType").readNullable[String]
        files <- (__ \ "files").readNullable[Seq[io.gimbalabs.hilltop.api.v0.models.NftMetadataFile]]
      } yield NftMetadata(name, image, mediaType, files)
    }

    def jsObjectNftMetadata(obj: io.gimbalabs.hilltop.api.v0.models.NftMetadata): play.api.libs.json.JsObject = {
      (obj.name match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("name" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.image match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("image" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.mediaType match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("mediaType" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.files match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("files" -> play.api.libs.json.Json.toJson(x))
      })
    }

    implicit def jsonWritesHilltopApiNftMetadata: play.api.libs.json.Writes[NftMetadata] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.NftMetadata) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectNftMetadata(obj)
      }
    }

    implicit def jsonReadsHilltopApiNftMetadataFile: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.NftMetadataFile] = {
      for {
        name <- (__ \ "name").readNullable[String]
        src <- (__ \ "src").readNullable[String]
        mediaType <- (__ \ "mediaType").readNullable[String]
      } yield NftMetadataFile(name, src, mediaType)
    }

    def jsObjectNftMetadataFile(obj: io.gimbalabs.hilltop.api.v0.models.NftMetadataFile): play.api.libs.json.JsObject = {
      (obj.name match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("name" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.src match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("src" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.mediaType match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("mediaType" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesHilltopApiNftMetadataFile: play.api.libs.json.Writes[NftMetadataFile] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.NftMetadataFile) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectNftMetadataFile(obj)
      }
    }

    implicit def jsonReadsHilltopApiNftMetadataFilesAsObject: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.NftMetadataFilesAsObject] = {
      for {
        name <- (__ \ "name").readNullable[String]
        image <- (__ \ "image").readNullable[String]
        mediaType <- (__ \ "mediaType").readNullable[String]
        files <- (__ \ "files").readNullable[io.gimbalabs.hilltop.api.v0.models.NftMetadataFile]
      } yield NftMetadataFilesAsObject(name, image, mediaType, files)
    }

    def jsObjectNftMetadataFilesAsObject(obj: io.gimbalabs.hilltop.api.v0.models.NftMetadataFilesAsObject): play.api.libs.json.JsObject = {
      (obj.name match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("name" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.image match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("image" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.mediaType match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("mediaType" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.files match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("files" -> io.gimbalabs.hilltop.api.v0.models.json.jsObjectNftMetadataFile(x))
      })
    }

    implicit def jsonWritesHilltopApiNftMetadataFilesAsObject: play.api.libs.json.Writes[NftMetadataFilesAsObject] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.NftMetadataFilesAsObject) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectNftMetadataFilesAsObject(obj)
      }
    }

    implicit def jsonReadsHilltopApiNftMetadataImgArray: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.NftMetadataImgArray] = {
      for {
        name <- (__ \ "name").readNullable[String]
        image <- (__ \ "image").readNullable[Seq[String]]
        mediaType <- (__ \ "mediaType").readNullable[String]
        files <- (__ \ "files").readNullable[Seq[io.gimbalabs.hilltop.api.v0.models.NftMetadataFile]]
      } yield NftMetadataImgArray(name, image, mediaType, files)
    }

    def jsObjectNftMetadataImgArray(obj: io.gimbalabs.hilltop.api.v0.models.NftMetadataImgArray): play.api.libs.json.JsObject = {
      (obj.name match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("name" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.image match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("image" -> play.api.libs.json.Json.toJson(x))
      }) ++
      (obj.mediaType match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("mediaType" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.files match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("files" -> play.api.libs.json.Json.toJson(x))
      })
    }

    implicit def jsonWritesHilltopApiNftMetadataImgArray: play.api.libs.json.Writes[NftMetadataImgArray] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.NftMetadataImgArray) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectNftMetadataImgArray(obj)
      }
    }

    implicit def jsonReadsHilltopApiNftMetadataNoFiles: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.NftMetadataNoFiles] = {
      for {
        name <- (__ \ "name").readNullable[String]
        image <- (__ \ "image").readNullable[String]
        mediaType <- (__ \ "mediaType").readNullable[String]
      } yield NftMetadataNoFiles(name, image, mediaType)
    }

    def jsObjectNftMetadataNoFiles(obj: io.gimbalabs.hilltop.api.v0.models.NftMetadataNoFiles): play.api.libs.json.JsObject = {
      (obj.name match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("name" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.image match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("image" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.mediaType match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("mediaType" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesHilltopApiNftMetadataNoFiles: play.api.libs.json.Writes[NftMetadataNoFiles] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.NftMetadataNoFiles) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectNftMetadataNoFiles(obj)
      }
    }

    implicit def jsonReadsHilltopApiPoolRetiring: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.PoolRetiring] = {
      for {
        tickerName <- (__ \ "ticker_name").readNullable[String]
        poolId <- (__ \ "pool_id").read[String]
        certificateIndex <- (__ \ "certificate_index").read[Int]
        epochNumber <- (__ \ "epoch_number").read[Long]
        blockNumber <- (__ \ "block_number").read[Long]
        retiringAtEpoch <- (__ \ "retiring_at_epoch").read[Long]
        txHash <- (__ \ "tx_hash").read[String]
      } yield PoolRetiring(tickerName, poolId, certificateIndex, epochNumber, blockNumber, retiringAtEpoch, txHash)
    }

    def jsObjectPoolRetiring(obj: io.gimbalabs.hilltop.api.v0.models.PoolRetiring): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "pool_id" -> play.api.libs.json.JsString(obj.poolId),
        "certificate_index" -> play.api.libs.json.JsNumber(obj.certificateIndex),
        "epoch_number" -> play.api.libs.json.JsNumber(obj.epochNumber),
        "block_number" -> play.api.libs.json.JsNumber(obj.blockNumber),
        "retiring_at_epoch" -> play.api.libs.json.JsNumber(obj.retiringAtEpoch),
        "tx_hash" -> play.api.libs.json.JsString(obj.txHash)
      ) ++ (obj.tickerName match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("ticker_name" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesHilltopApiPoolRetiring: play.api.libs.json.Writes[PoolRetiring] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.PoolRetiring) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectPoolRetiring(obj)
      }
    }

    implicit def jsonReadsHilltopApiPoolUpdate: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.PoolUpdate] = {
      for {
        epochNumber <- (__ \ "epoch_number").read[Int]
        blockNumber <- (__ \ "block_number").read[Long]
        txHash <- (__ \ "tx_hash").read[String]
        poolTickerName <- (__ \ "pool_ticker_name").readNullable[String]
        poolBech32Id <- (__ \ "pool_bech32_id").read[String]
        certificateIndex <- (__ \ "certificate_index").read[Int]
        vrfKeyHash <- (__ \ "vrf_key_hash").read[String]
        pledge <- (__ \ "pledge").read[Long]
        rewardAddress <- (__ \ "reward_address").read[String]
        activeEpochNumber <- (__ \ "active_epoch_number").read[Long]
        margin <- (__ \ "margin").read[Double]
        fixedCost <- (__ \ "fixed_cost").read[Long]
      } yield PoolUpdate(epochNumber, blockNumber, txHash, poolTickerName, poolBech32Id, certificateIndex, vrfKeyHash, pledge, rewardAddress, activeEpochNumber, margin, fixedCost)
    }

    def jsObjectPoolUpdate(obj: io.gimbalabs.hilltop.api.v0.models.PoolUpdate): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "epoch_number" -> play.api.libs.json.JsNumber(obj.epochNumber),
        "block_number" -> play.api.libs.json.JsNumber(obj.blockNumber),
        "tx_hash" -> play.api.libs.json.JsString(obj.txHash),
        "pool_bech32_id" -> play.api.libs.json.JsString(obj.poolBech32Id),
        "certificate_index" -> play.api.libs.json.JsNumber(obj.certificateIndex),
        "vrf_key_hash" -> play.api.libs.json.JsString(obj.vrfKeyHash),
        "pledge" -> play.api.libs.json.JsNumber(obj.pledge),
        "reward_address" -> play.api.libs.json.JsString(obj.rewardAddress),
        "active_epoch_number" -> play.api.libs.json.JsNumber(obj.activeEpochNumber),
        "margin" -> play.api.libs.json.JsNumber(obj.margin),
        "fixed_cost" -> play.api.libs.json.JsNumber(obj.fixedCost)
      ) ++ (obj.poolTickerName match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("pool_ticker_name" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesHilltopApiPoolUpdate: play.api.libs.json.Writes[PoolUpdate] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.PoolUpdate) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectPoolUpdate(obj)
      }
    }

    implicit def jsonReadsHilltopApiReward: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.Reward] = {
      for {
        stakingAddress <- (__ \ "staking_address").read[String]
        epoch <- (__ \ "epoch").read[Int]
        amount <- (__ \ "amount").read[Long]
        poolId <- (__ \ "pool_id").read[String]
      } yield Reward(stakingAddress, epoch, amount, poolId)
    }

    def jsObjectReward(obj: io.gimbalabs.hilltop.api.v0.models.Reward): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "staking_address" -> play.api.libs.json.JsString(obj.stakingAddress),
        "epoch" -> play.api.libs.json.JsNumber(obj.epoch),
        "amount" -> play.api.libs.json.JsNumber(obj.amount),
        "pool_id" -> play.api.libs.json.JsString(obj.poolId)
      )
    }

    implicit def jsonWritesHilltopApiReward: play.api.libs.json.Writes[Reward] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.Reward) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectReward(obj)
      }
    }

    implicit def jsonReadsHilltopApiSigma: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.Sigma] = {
      for {
        sigma <- (__ \ "sigma").read[Double]
        epoch <- (__ \ "epoch").read[Int]
        totalStaked <- (__ \ "total_staked").read[Long]
        activeStake <- (__ \ "active_stake").read[Long]
        nonce <- (__ \ "nonce").read[String]
        d <- (__ \ "d").read[Double]
      } yield Sigma(sigma, epoch, totalStaked, activeStake, nonce, d)
    }

    def jsObjectSigma(obj: io.gimbalabs.hilltop.api.v0.models.Sigma): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "sigma" -> play.api.libs.json.JsNumber(obj.sigma),
        "epoch" -> play.api.libs.json.JsNumber(obj.epoch),
        "total_staked" -> play.api.libs.json.JsNumber(obj.totalStaked),
        "active_stake" -> play.api.libs.json.JsNumber(obj.activeStake),
        "nonce" -> play.api.libs.json.JsString(obj.nonce),
        "d" -> play.api.libs.json.JsNumber(obj.d)
      )
    }

    implicit def jsonWritesHilltopApiSigma: play.api.libs.json.Writes[Sigma] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.Sigma) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectSigma(obj)
      }
    }

    implicit def jsonReadsHilltopApiStakepool: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.Stakepool] = {
      for {
        id <- (__ \ "id").read[String]
        poolIdBech32 <- (__ \ "pool_id_bech32").read[String]
        metadata <- (__ \ "metadata").readNullable[io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata]
        cost <- (__ \ "cost").read[Long]
        margin <- (__ \ "margin").read[Double]
        pledge <- (__ \ "pledge").read[Long]
        activeStake <- (__ \ "active_stake").read[Long]
        saturation <- (__ \ "saturation").read[Double]
        retiringAtEpoch <- (__ \ "retiring_at_epoch").readNullable[Long]
      } yield Stakepool(id, poolIdBech32, metadata, cost, margin, pledge, activeStake, saturation, retiringAtEpoch)
    }

    def jsObjectStakepool(obj: io.gimbalabs.hilltop.api.v0.models.Stakepool): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "pool_id_bech32" -> play.api.libs.json.JsString(obj.poolIdBech32),
        "cost" -> play.api.libs.json.JsNumber(obj.cost),
        "margin" -> play.api.libs.json.JsNumber(obj.margin),
        "pledge" -> play.api.libs.json.JsNumber(obj.pledge),
        "active_stake" -> play.api.libs.json.JsNumber(obj.activeStake),
        "saturation" -> play.api.libs.json.JsNumber(obj.saturation)
      ) ++ (obj.metadata match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("metadata" -> io.gimbalabs.hilltop.api.v0.models.json.jsObjectStakepoolMetadata(x))
      }) ++
      (obj.retiringAtEpoch match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("retiring_at_epoch" -> play.api.libs.json.JsNumber(x))
      })
    }

    implicit def jsonWritesHilltopApiStakepool: play.api.libs.json.Writes[Stakepool] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.Stakepool) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectStakepool(obj)
      }
    }

    implicit def jsonReadsHilltopApiStakepoolDelegation: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.StakepoolDelegation] = {
      for {
        stakepool <- (__ \ "stakepool").read[io.gimbalabs.hilltop.api.v0.models.Stakepool]
        epoch <- (__ \ "epoch").read[Int]
      } yield StakepoolDelegation(stakepool, epoch)
    }

    def jsObjectStakepoolDelegation(obj: io.gimbalabs.hilltop.api.v0.models.StakepoolDelegation): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "stakepool" -> io.gimbalabs.hilltop.api.v0.models.json.jsObjectStakepool(obj.stakepool),
        "epoch" -> play.api.libs.json.JsNumber(obj.epoch)
      )
    }

    implicit def jsonWritesHilltopApiStakepoolDelegation: play.api.libs.json.Writes[StakepoolDelegation] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.StakepoolDelegation) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectStakepoolDelegation(obj)
      }
    }

    implicit def jsonReadsHilltopApiStakepoolMetadata: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata] = {
      for {
        name <- (__ \ "name").read[String]
        ticker <- (__ \ "ticker").read[String]
        homepage <- (__ \ "homepage").read[String]
        description <- (__ \ "description").read[String]
        extended <- (__ \ "extended").readNullable[String]
      } yield StakepoolMetadata(name, ticker, homepage, description, extended)
    }

    def jsObjectStakepoolMetadata(obj: io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "name" -> play.api.libs.json.JsString(obj.name),
        "ticker" -> play.api.libs.json.JsString(obj.ticker),
        "homepage" -> play.api.libs.json.JsString(obj.homepage),
        "description" -> play.api.libs.json.JsString(obj.description)
      ) ++ (obj.extended match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("extended" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesHilltopApiStakepoolMetadata: play.api.libs.json.Writes[StakepoolMetadata] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectStakepoolMetadata(obj)
      }
    }

    implicit def jsonReadsHilltopApiTransaction: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.Transaction] = {
      for {
        hash <- (__ \ "hash").read[String]
        block <- (__ \ "block").read[Long]
        timestamp <- (__ \ "timestamp").read[_root_.org.joda.time.DateTime]
      } yield Transaction(hash, block, timestamp)
    }

    def jsObjectTransaction(obj: io.gimbalabs.hilltop.api.v0.models.Transaction): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "hash" -> play.api.libs.json.JsString(obj.hash),
        "block" -> play.api.libs.json.JsNumber(obj.block),
        "timestamp" -> play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.dateTime.print(obj.timestamp))
      )
    }

    implicit def jsonWritesHilltopApiTransaction: play.api.libs.json.Writes[Transaction] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.Transaction) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectTransaction(obj)
      }
    }

    implicit def jsonReadsHilltopApiTransactionHistoryRequest: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.TransactionHistoryRequest] = {
      (__ \ "addresses").read[Seq[String]].map { x => TransactionHistoryRequest(addresses = x) }
    }

    def jsObjectTransactionHistoryRequest(obj: io.gimbalabs.hilltop.api.v0.models.TransactionHistoryRequest): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "addresses" -> play.api.libs.json.Json.toJson(obj.addresses)
      )
    }

    implicit def jsonWritesHilltopApiTransactionHistoryRequest: play.api.libs.json.Writes[TransactionHistoryRequest] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.TransactionHistoryRequest) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectTransactionHistoryRequest(obj)
      }
    }

    implicit def jsonReadsHilltopApiWalletBalance: play.api.libs.json.Reads[io.gimbalabs.hilltop.api.v0.models.WalletBalance] = {
      (__ \ "balance").read[Long].map { x => WalletBalance(balance = x) }
    }

    def jsObjectWalletBalance(obj: io.gimbalabs.hilltop.api.v0.models.WalletBalance): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "balance" -> play.api.libs.json.JsNumber(obj.balance)
      )
    }

    implicit def jsonWritesHilltopApiWalletBalance: play.api.libs.json.Writes[WalletBalance] = {
      (obj: io.gimbalabs.hilltop.api.v0.models.WalletBalance) => {
        io.gimbalabs.hilltop.api.v0.models.json.jsObjectWalletBalance(obj)
      }
    }
  }
}

package io.gimbalabs.hilltop.api.v0 {

  object Bindables {

    import play.api.mvc.{PathBindable, QueryStringBindable}

    // import models directly for backwards compatibility with prior versions of the generator
    import Core._
    import Models._

    object Core {
      implicit def pathBindableDateTimeIso8601(implicit stringBinder: QueryStringBindable[String]): PathBindable[_root_.org.joda.time.DateTime] = ApibuilderPathBindable(ApibuilderTypes.dateTimeIso8601)
      implicit def queryStringBindableDateTimeIso8601(implicit stringBinder: QueryStringBindable[String]): QueryStringBindable[_root_.org.joda.time.DateTime] = ApibuilderQueryStringBindable(ApibuilderTypes.dateTimeIso8601)

      implicit def pathBindableDateIso8601(implicit stringBinder: QueryStringBindable[String]): PathBindable[_root_.org.joda.time.LocalDate] = ApibuilderPathBindable(ApibuilderTypes.dateIso8601)
      implicit def queryStringBindableDateIso8601(implicit stringBinder: QueryStringBindable[String]): QueryStringBindable[_root_.org.joda.time.LocalDate] = ApibuilderQueryStringBindable(ApibuilderTypes.dateIso8601)
    }

    object Models {
      import io.gimbalabs.hilltop.api.v0.models._

      val countryConverter: ApibuilderTypeConverter[io.gimbalabs.hilltop.api.v0.models.Country] = new ApibuilderTypeConverter[io.gimbalabs.hilltop.api.v0.models.Country] {
        override def convert(value: String): io.gimbalabs.hilltop.api.v0.models.Country = io.gimbalabs.hilltop.api.v0.models.Country(value)
        override def convert(value: io.gimbalabs.hilltop.api.v0.models.Country): String = value.toString
        override def example: io.gimbalabs.hilltop.api.v0.models.Country = io.gimbalabs.hilltop.api.v0.models.Country.Ie
        override def validValues: Seq[io.gimbalabs.hilltop.api.v0.models.Country] = io.gimbalabs.hilltop.api.v0.models.Country.all
      }
      implicit def pathBindableCountry(implicit stringBinder: QueryStringBindable[String]): PathBindable[io.gimbalabs.hilltop.api.v0.models.Country] = ApibuilderPathBindable(countryConverter)
      implicit def queryStringBindableCountry(implicit stringBinder: QueryStringBindable[String]): QueryStringBindable[io.gimbalabs.hilltop.api.v0.models.Country] = ApibuilderQueryStringBindable(countryConverter)
    }

    trait ApibuilderTypeConverter[T] {

      def convert(value: String): T

      def convert(value: T): String

      def example: T

      def validValues: Seq[T] = Nil

      def errorMessage(key: String, value: String, ex: java.lang.Exception): String = {
        val base = s"Invalid value '$value' for parameter '$key'. "
        validValues.toList match {
          case Nil => base + "Ex: " + convert(example)
          case values => base + ". Valid values are: " + values.mkString("'", "', '", "'")
        }
      }
    }

    object ApibuilderTypes {
      val dateTimeIso8601: ApibuilderTypeConverter[_root_.org.joda.time.DateTime] = new ApibuilderTypeConverter[_root_.org.joda.time.DateTime] {
        override def convert(value: String): _root_.org.joda.time.DateTime = _root_.org.joda.time.format.ISODateTimeFormat.dateTimeParser.parseDateTime(value)
        override def convert(value: _root_.org.joda.time.DateTime): String = _root_.org.joda.time.format.ISODateTimeFormat.dateTime.print(value)
        override def example: _root_.org.joda.time.DateTime = _root_.org.joda.time.DateTime.now
      }

      val dateIso8601: ApibuilderTypeConverter[_root_.org.joda.time.LocalDate] = new ApibuilderTypeConverter[_root_.org.joda.time.LocalDate] {
        override def convert(value: String): _root_.org.joda.time.LocalDate = _root_.org.joda.time.format.ISODateTimeFormat.dateTimeParser.parseLocalDate(value)
        override def convert(value: _root_.org.joda.time.LocalDate): String = _root_.org.joda.time.format.ISODateTimeFormat.date.print(value)
        override def example: _root_.org.joda.time.LocalDate = _root_.org.joda.time.LocalDate.now
      }
    }

    final case class ApibuilderQueryStringBindable[T](
      converters: ApibuilderTypeConverter[T]
    ) extends QueryStringBindable[T] {

      override def bind(key: String, params: Map[String, Seq[String]]): _root_.scala.Option[_root_.scala.Either[String, T]] = {
        params.getOrElse(key, Nil).headOption.map { v =>
          try {
            Right(
              converters.convert(v)
            )
          } catch {
            case ex: java.lang.Exception => Left(
              converters.errorMessage(key, v, ex)
            )
          }
        }
      }

      override def unbind(key: String, value: T): String = {
        s"$key=${converters.convert(value)}"
      }
    }

    final case class ApibuilderPathBindable[T](
      converters: ApibuilderTypeConverter[T]
    ) extends PathBindable[T] {

      override def bind(key: String, value: String): _root_.scala.Either[String, T] = {
        try {
          Right(
            converters.convert(value)
          )
        } catch {
          case ex: java.lang.Exception => Left(
            converters.errorMessage(key, value, ex)
          )
        }
      }

      override def unbind(key: String, value: T): String = {
        converters.convert(value)
      }
    }

  }

}


package io.gimbalabs.hilltop.api.v0 {

  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/play_2_8_client"
    val Version = "0.0.1-SNAPSHOT"
    val VersionMajor = 0

  }

  class Client(
    ws: play.api.libs.ws.WSClient,
    val baseUrl: String = "https://hilltop-api.mainnet.dandelion.link",
    auth: scala.Option[io.gimbalabs.hilltop.api.v0.Authorization] = None,
    defaultHeaders: Seq[(String, String)] = Nil
  ) extends interfaces.Client {
    import io.gimbalabs.hilltop.api.v0.models.json._

    private val logger = play.api.Logger("io.gimbalabs.hilltop.api.v0.Client")

    logger.info(s"Initializing io.gimbalabs.hilltop.api.v0.Client for url $baseUrl")

    def activeStakeAmounts: ActiveStakeAmounts = ActiveStakeAmounts

    def blocks: Blocks = Blocks

    def delegations: Delegations = Delegations

    def delegatorsCounts: DelegatorsCounts = DelegatorsCounts

    def epochs: Epochs = Epochs

    def healthchecks: Healthchecks = Healthchecks

    def nativeAssets: NativeAssets = NativeAssets

    def poolUpdates: PoolUpdates = PoolUpdates

    def rewards: Rewards = Rewards

    def sigmas: Sigmas = Sigmas

    def stakepoolMetadata: StakepoolMetadata = StakepoolMetadata

    def stakepools: Stakepools = Stakepools

    def transactions: Transactions = Transactions

    def walletBalances: WalletBalances = WalletBalances

    object ActiveStakeAmounts extends ActiveStakeAmounts {
      override def get(
        epochNumber: _root_.scala.Option[Int] = None,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount] = {
        val queryParameters = Seq(
          epochNumber.map("epoch_number" -> _.toString)
        ).flatten

        _executeRequest("GET", s"/active_stake_amounts", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount", r, _.validate[io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount])
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def getByPoolBech32Id(
        poolBech32Id: String,
        epochNumber: _root_.scala.Option[Int] = None,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount] = {
        val queryParameters = Seq(
          epochNumber.map("epoch_number" -> _.toString)
        ).flatten

        _executeRequest("GET", s"/active_stake_amounts/${play.utils.UriEncoding.encodePathSegment(poolBech32Id, "UTF-8")}", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount", r, _.validate[io.gimbalabs.hilltop.api.v0.models.ActiveStakeAmount])
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def getAddressesByPoolBech32Id(
        poolBech32Id: String,
        epochNumber: Int,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.AddressStakeAmount]] = {
        val queryParameters = Seq(
          Some("epoch_number" -> epochNumber.toString)
        ).flatten

        _executeRequest("GET", s"/active_stake_amounts/${play.utils.UriEncoding.encodePathSegment(poolBech32Id, "UTF-8")}/addresses", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("Seq[io.gimbalabs.hilltop.api.v0.models.AddressStakeAmount]", r, _.validate[Seq[io.gimbalabs.hilltop.api.v0.models.AddressStakeAmount]])
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }
    }

    object Blocks extends Blocks {
      override def getBlocksInDay(
        date: _root_.org.joda.time.LocalDate,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.DayBlock] = {
        val queryParameters = Seq(
          Some("date" -> _root_.org.joda.time.format.ISODateTimeFormat.date.print(date))
        ).flatten

        _executeRequest("GET", s"/blocks/blocks_in_day", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("io.gimbalabs.hilltop.api.v0.models.DayBlock", r, _.validate[io.gimbalabs.hilltop.api.v0.models.DayBlock])
          case r if r.status == 404 => throw io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r)
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

      override def getByBlockNumber(
        blockNumber: Long,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.Block] = {
        _executeRequest("GET", s"/blocks/${blockNumber}", requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("io.gimbalabs.hilltop.api.v0.models.Block", r, _.validate[io.gimbalabs.hilltop.api.v0.models.Block])
          case r if r.status == 404 => throw io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r)
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }
    }

    object Delegations extends Delegations {
      override def getSafePaymentByStakingAddress(
        stakingAddress: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[String] = {
        _executeRequest("GET", s"/delegations/${play.utils.UriEncoding.encodePathSegment(stakingAddress, "UTF-8")}/safe_payment", requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("String", r, _.validate[String])
          case r if r.status == 404 => throw io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r)
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

      override def getStakepoolByStakingAddress(
        stakingAddress: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.Delegation] = {
        _executeRequest("GET", s"/delegations/${play.utils.UriEncoding.encodePathSegment(stakingAddress, "UTF-8")}/stakepool", requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("io.gimbalabs.hilltop.api.v0.models.Delegation", r, _.validate[io.gimbalabs.hilltop.api.v0.models.Delegation])
          case r if r.status == 404 => throw io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r)
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }
    }

    object DelegatorsCounts extends DelegatorsCounts {
      override def getByPoolBech32Id(
        poolBech32Id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.DelegatorsCount] = {
        _executeRequest("GET", s"/delegators_counts/${play.utils.UriEncoding.encodePathSegment(poolBech32Id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("io.gimbalabs.hilltop.api.v0.models.DelegatorsCount", r, _.validate[io.gimbalabs.hilltop.api.v0.models.DelegatorsCount])
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }
    }

    object Epochs extends Epochs {
      override def getCurrent(
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.Epoch] = {
        _executeRequest("GET", s"/epochs/current", requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("io.gimbalabs.hilltop.api.v0.models.Epoch", r, _.validate[io.gimbalabs.hilltop.api.v0.models.Epoch])
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def getByEpochNumber(
        epochNumber: Int,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.Epoch] = {
        _executeRequest("GET", s"/epochs/${epochNumber}", requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("io.gimbalabs.hilltop.api.v0.models.Epoch", r, _.validate[io.gimbalabs.hilltop.api.v0.models.Epoch])
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }
    }

    object Healthchecks extends Healthchecks {
      override def get(
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.Healthcheck] = {
        _executeRequest("GET", s"/healthchecks", requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("io.gimbalabs.hilltop.api.v0.models.Healthcheck", r, _.validate[io.gimbalabs.hilltop.api.v0.models.Healthcheck])
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }
    }

    object NativeAssets extends NativeAssets {
      override def getIds(
        blockNumberFrom: _root_.scala.Option[Long] = None,
        limit: _root_.scala.Option[Long] = None,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetId]] = {
        val queryParameters = Seq(
          blockNumberFrom.map("block_number_from" -> _.toString),
          limit.map("limit" -> _.toString)
        ).flatten

        _executeRequest("GET", s"/native_assets/ids", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetId]", r, _.validate[Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetId]])
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def getAssetNamesByPolicyId(
        policyId: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[String]] = {
        _executeRequest("GET", s"/native_assets/${play.utils.UriEncoding.encodePathSegment(policyId, "UTF-8")}/asset_names", requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("Seq[String]", r, _.validate[Seq[String]])
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def getNfts(
        blockNumberFrom: Long,
        blockNumberTo: Long,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.NftDetails]] = {
        val queryParameters = Seq(
          Some("block_number_from" -> blockNumberFrom.toString),
          Some("block_number_to" -> blockNumberTo.toString)
        ).flatten

        _executeRequest("GET", s"/native_assets/nfts", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("Seq[io.gimbalabs.hilltop.api.v0.models.NftDetails]", r, _.validate[Seq[io.gimbalabs.hilltop.api.v0.models.NftDetails]])
          case r if r.status == 404 => throw io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r)
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

      override def postNativeAssetsDetails(
        nativeAssetDetailsRequest: io.gimbalabs.hilltop.api.v0.models.NativeAssetDetailsRequest,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetDetails]] = {
        val payload = play.api.libs.json.Json.toJson(nativeAssetDetailsRequest)

        _executeRequest("POST", s"/native_assets/native_assets_details", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetDetails]", r, _.validate[Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetDetails]])
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def getByStakeAddress(
        stakeAddress: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.NativeAsset]] = {
        _executeRequest("GET", s"/native_assets/${play.utils.UriEncoding.encodePathSegment(stakeAddress, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("Seq[io.gimbalabs.hilltop.api.v0.models.NativeAsset]", r, _.validate[Seq[io.gimbalabs.hilltop.api.v0.models.NativeAsset]])
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }
    }

    object PoolUpdates extends PoolUpdates {
      override def getRetiring(
        blockNumberFrom: _root_.scala.Option[Long] = None,
        limit: _root_.scala.Option[Long] = None,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.PoolRetiring]] = {
        val queryParameters = Seq(
          blockNumberFrom.map("block_number_from" -> _.toString),
          limit.map("limit" -> _.toString)
        ).flatten

        _executeRequest("GET", s"/pool_updates/retiring", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("Seq[io.gimbalabs.hilltop.api.v0.models.PoolRetiring]", r, _.validate[Seq[io.gimbalabs.hilltop.api.v0.models.PoolRetiring]])
          case r if r.status == 404 => throw io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r)
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. 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
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]] = {
        val queryParameters = Seq(
          blockNumberFrom.map("block_number_from" -> _.toString),
          limit.map("limit" -> _.toString)
        ).flatten

        _executeRequest("GET", s"/pool_updates/${play.utils.UriEncoding.encodePathSegment(poolId, "UTF-8")}", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]", r, _.validate[Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]])
          case r if r.status == 404 => throw io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r)
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

      override def get(
        blockNumberFrom: _root_.scala.Option[Long] = None,
        limit: _root_.scala.Option[Long] = None,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]] = {
        val queryParameters = Seq(
          blockNumberFrom.map("block_number_from" -> _.toString),
          limit.map("limit" -> _.toString)
        ).flatten

        _executeRequest("GET", s"/pool_updates", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]", r, _.validate[Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]])
          case r if r.status == 404 => throw io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r)
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }
    }

    object Rewards extends Rewards {
      override def getByStakingAddress(
        stakingAddress: String,
        epochFrom: _root_.scala.Option[Int] = None,
        epochTo: _root_.scala.Option[Int] = None,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.Reward]] = {
        val queryParameters = Seq(
          epochFrom.map("epoch_from" -> _.toString),
          epochTo.map("epoch_to" -> _.toString)
        ).flatten

        _executeRequest("GET", s"/rewards/${play.utils.UriEncoding.encodePathSegment(stakingAddress, "UTF-8")}", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("Seq[io.gimbalabs.hilltop.api.v0.models.Reward]", r, _.validate[Seq[io.gimbalabs.hilltop.api.v0.models.Reward]])
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }
    }

    object Sigmas extends Sigmas {
      override def getByPoolId(
        poolId: String,
        epochNumber: Int,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.Sigma] = {
        val queryParameters = Seq(
          Some("epoch_number" -> epochNumber.toString)
        ).flatten

        _executeRequest("GET", s"/sigmas/${play.utils.UriEncoding.encodePathSegment(poolId, "UTF-8")}", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("io.gimbalabs.hilltop.api.v0.models.Sigma", r, _.validate[io.gimbalabs.hilltop.api.v0.models.Sigma])
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }
    }

    object StakepoolMetadata extends StakepoolMetadata {
      override def getByPoolIdBech32(
        poolIdBech32: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata] = {
        _executeRequest("GET", s"/stakepool_metadata/${play.utils.UriEncoding.encodePathSegment(poolIdBech32, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata", r, _.validate[io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata])
          case r if r.status == 404 => throw io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r)
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }
    }

    object Stakepools extends Stakepools {
      override def getVrfVkeyByVrfVkeyHash(
        vrfVkeyHash: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.Stakepool] = {
        _executeRequest("GET", s"/stakepools/vrf_vkey/${play.utils.UriEncoding.encodePathSegment(vrfVkeyHash, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("io.gimbalabs.hilltop.api.v0.models.Stakepool", r, _.validate[io.gimbalabs.hilltop.api.v0.models.Stakepool])
          case r if r.status == 404 => throw io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r)
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

      override def getEstablishedEpochByPoolId(
        poolId: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Int] = {
        _executeRequest("GET", s"/stakepools/${play.utils.UriEncoding.encodePathSegment(poolId, "UTF-8")}/established_epoch", requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("Int", r, _.validate[Int])
          case r if r.status == 404 => throw io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r)
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

      override def getLiveStakeByPoolId(
        poolId: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Long] = {
        _executeRequest("GET", s"/stakepools/${play.utils.UriEncoding.encodePathSegment(poolId, "UTF-8")}/live_stake", requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("Long", r, _.validate[Long])
          case r if r.status == 404 => throw io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r)
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

      override def getBlocksByPoolId(
        poolId: String,
        epoch: _root_.scala.Option[Int] = None,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Int] = {
        val queryParameters = Seq(
          epoch.map("epoch" -> _.toString)
        ).flatten

        _executeRequest("GET", s"/stakepools/${play.utils.UriEncoding.encodePathSegment(poolId, "UTF-8")}/blocks", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("Int", r, _.validate[Int])
          case r if r.status == 404 => throw io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r)
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

      override def get(
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.Stakepool]] = {
        _executeRequest("GET", s"/stakepools", requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("Seq[io.gimbalabs.hilltop.api.v0.models.Stakepool]", r, _.validate[Seq[io.gimbalabs.hilltop.api.v0.models.Stakepool]])
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }
    }

    object Transactions extends Transactions {
      override def postHistory(
        transactionHistoryRequest: io.gimbalabs.hilltop.api.v0.models.TransactionHistoryRequest,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.Transaction]] = {
        val payload = play.api.libs.json.Json.toJson(transactionHistoryRequest)

        _executeRequest("POST", s"/transactions/history", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("Seq[io.gimbalabs.hilltop.api.v0.models.Transaction]", r, _.validate[Seq[io.gimbalabs.hilltop.api.v0.models.Transaction]])
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }
    }

    object WalletBalances extends WalletBalances {
      override def getByStakingAddress(
        stakingAddress: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.WalletBalance] = {
        _executeRequest("GET", s"/wallet_balances/${play.utils.UriEncoding.encodePathSegment(stakingAddress, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.status == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("io.gimbalabs.hilltop.api.v0.models.WalletBalance", r, _.validate[io.gimbalabs.hilltop.api.v0.models.WalletBalance])
          case r => throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }
    }

    def _requestHolder(path: String): play.api.libs.ws.WSRequest = {

      val holder = ws.url(baseUrl + path).addHttpHeaders(
        "User-Agent" -> Constants.UserAgent,
        "X-Apidoc-Version" -> Constants.Version,
        "X-Apidoc-Version-Major" -> Constants.VersionMajor.toString
      ).addHttpHeaders(defaultHeaders: _*)
      auth.fold(holder) {
        case Authorization.Basic(username, password) => {
          holder.withAuth(username, password.getOrElse(""), play.api.libs.ws.WSAuthScheme.BASIC)
        }
      }
    }

    def _logRequest(method: String, req: play.api.libs.ws.WSRequest): play.api.libs.ws.WSRequest = {
      val queryComponents = for {
        (name, values) <- req.queryString
        value <- values
      } yield s"$name=$value"
      val url = s"${req.url}${queryComponents.mkString("?", "&", "")}"
      auth.fold(logger.info(s"curl -X $method '$url'")) { _ =>
        logger.info(s"curl -X $method -u '[REDACTED]:' '$url'")
      }
      req
    }

    def _executeRequest(
      method: String,
      path: String,
      queryParameters: Seq[(String, String)] = Nil,
      requestHeaders: Seq[(String, String)] = Nil,
      body: Option[play.api.libs.json.JsValue] = None
    ): scala.concurrent.Future[play.api.libs.ws.WSResponse] = {
      method.toUpperCase match {
        case "GET" => {
          _logRequest("GET", _requestHolder(path).addHttpHeaders(requestHeaders: _*).addQueryStringParameters(queryParameters: _*)).get()
        }
        case "POST" => {
          _logRequest("POST", _requestHolder(path).addHttpHeaders(_withJsonContentType(requestHeaders): _*).addQueryStringParameters(queryParameters: _*)).post(body.getOrElse(play.api.libs.json.Json.obj()))
        }
        case "PUT" => {
          _logRequest("PUT", _requestHolder(path).addHttpHeaders(_withJsonContentType(requestHeaders): _*).addQueryStringParameters(queryParameters: _*)).put(body.getOrElse(play.api.libs.json.Json.obj()))
        }
        case "PATCH" => {
          _logRequest("PATCH", _requestHolder(path).addHttpHeaders(requestHeaders: _*).addQueryStringParameters(queryParameters: _*)).patch(body.getOrElse(play.api.libs.json.Json.obj()))
        }
        case "DELETE" => {
          _logRequest("DELETE", _requestHolder(path).addHttpHeaders(requestHeaders: _*).addQueryStringParameters(queryParameters: _*)).delete()
        }
         case "HEAD" => {
          _logRequest("HEAD", _requestHolder(path).addHttpHeaders(requestHeaders: _*).addQueryStringParameters(queryParameters: _*)).head()
        }
         case "OPTIONS" => {
          _logRequest("OPTIONS", _requestHolder(path).addHttpHeaders(requestHeaders: _*).addQueryStringParameters(queryParameters: _*)).options()
        }
        case _ => {
          _logRequest(method, _requestHolder(path).addHttpHeaders(requestHeaders: _*).addQueryStringParameters(queryParameters: _*))
          sys.error("Unsupported method[%s]".format(method))
        }
      }
    }

    /**
     * Adds a Content-Type: application/json header unless the specified requestHeaders
     * already contain a Content-Type header
     */
    def _withJsonContentType(headers: Seq[(String, String)]): Seq[(String, String)] = {
      headers.find { _._1.toUpperCase == "CONTENT-TYPE" } match {
        case None => headers ++ Seq("Content-Type" -> "application/json; charset=UTF-8")
        case Some(_) => headers
      }
    }

  }

  object Client {

    def parseJson[T](
      className: String,
      r: play.api.libs.ws.WSResponse,
      f: (play.api.libs.json.JsValue => play.api.libs.json.JsResult[T])
    ): T = {
      f(play.api.libs.json.Json.parse(r.body)) match {
        case play.api.libs.json.JsSuccess(x, _) => x
        case play.api.libs.json.JsError(errors) => {
          throw io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status, s"Invalid json for class[" + className + "]: " + errors.mkString(" "))
        }
      }
    }

  }

  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 {
      def baseUrl: String
      def activeStakeAmounts: io.gimbalabs.hilltop.api.v0.ActiveStakeAmounts
      def blocks: io.gimbalabs.hilltop.api.v0.Blocks
      def delegations: io.gimbalabs.hilltop.api.v0.Delegations
      def delegatorsCounts: io.gimbalabs.hilltop.api.v0.DelegatorsCounts
      def epochs: io.gimbalabs.hilltop.api.v0.Epochs
      def healthchecks: io.gimbalabs.hilltop.api.v0.Healthchecks
      def nativeAssets: io.gimbalabs.hilltop.api.v0.NativeAssets
      def poolUpdates: io.gimbalabs.hilltop.api.v0.PoolUpdates
      def rewards: io.gimbalabs.hilltop.api.v0.Rewards
      def sigmas: io.gimbalabs.hilltop.api.v0.Sigmas
      def stakepoolMetadata: io.gimbalabs.hilltop.api.v0.StakepoolMetadata
      def stakepools: io.gimbalabs.hilltop.api.v0.Stakepools
      def transactions: io.gimbalabs.hilltop.api.v0.Transactions
      def walletBalances: io.gimbalabs.hilltop.api.v0.WalletBalances
    }

  }

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

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

    def getAddressesByPoolBech32Id(
      poolBech32Id: String,
      epochNumber: Int,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.AddressStakeAmount]]
  }

  trait Blocks {
    def getBlocksInDay(
      date: _root_.org.joda.time.LocalDate,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.DayBlock]

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

  trait Delegations {
    def getSafePaymentByStakingAddress(
      stakingAddress: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[String]

    def getStakepoolByStakingAddress(
      stakingAddress: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.Delegation]
  }

  trait DelegatorsCounts {
    def getByPoolBech32Id(
      poolBech32Id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.DelegatorsCount]
  }

  trait Epochs {
    def getCurrent(
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.Epoch]

    def getByEpochNumber(
      epochNumber: Int,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.Epoch]
  }

  trait Healthchecks {
    def get(
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.Healthcheck]
  }

  trait NativeAssets {
    /**
     * @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
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[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
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[String]]

    def getNfts(
      blockNumberFrom: Long,
      blockNumberTo: Long,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.NftDetails]]

    def postNativeAssetsDetails(
      nativeAssetDetailsRequest: io.gimbalabs.hilltop.api.v0.models.NativeAssetDetailsRequest,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.NativeAssetDetails]]

    def getByStakeAddress(
      stakeAddress: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.NativeAsset]]
  }

  trait PoolUpdates {
    /**
     * @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
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[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
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[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
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]]
  }

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

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

  trait StakepoolMetadata {
    def getByPoolIdBech32(
      poolIdBech32: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata]
  }

  trait Stakepools {
    /**
     * find pool details by vrf_vkey
     *
     * @param vrfVkeyHash the hash of the vrf_vkey
     */
    def getVrfVkeyByVrfVkeyHash(
      vrfVkeyHash: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[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
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[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
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[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
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Int]

    def get(
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.Stakepool]]
  }

  trait Transactions {
    def postHistory(
      transactionHistoryRequest: io.gimbalabs.hilltop.api.v0.models.TransactionHistoryRequest,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.gimbalabs.hilltop.api.v0.models.Transaction]]
  }

  trait WalletBalances {
    def getByStakingAddress(
      stakingAddress: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.gimbalabs.hilltop.api.v0.models.WalletBalance]
  }

  package errors {

    import io.gimbalabs.hilltop.api.v0.models.json._

    final case class GenericErrorResponse(
      response: play.api.libs.ws.WSResponse,
      message: Option[String] = None
    ) extends Exception(message.getOrElse(s"${response.status}: ${response.body}")) {
      lazy val genericError = _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson("io.gimbalabs.hilltop.api.v0.models.GenericError", response, _.validate[io.gimbalabs.hilltop.api.v0.models.GenericError])
    }

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

  }

}