/**
 * 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_x_standalone_json
 */
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)
      }
    }
  }
}