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

package object json {

  import play.api.libs.json.{__, JsString, Writes}
  import play.api.libs.functional.syntax._

  import play.api.libs.json.Writes._
  import play.api.libs.json.Reads._

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

  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_.java.time.OffsetDateTime]
    } 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(obj.time.toString)
    )
  }

  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_.java.time.OffsetDateTime]
      endTime <- (__ \ "end_time").read[_root_.java.time.OffsetDateTime]
    } 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(obj.startTime.toString),
      "end_time" -> play.api.libs.json.JsString(obj.endTime.toString)
    )
  }

  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_.java.time.OffsetDateTime]
      lastMintedAt <- (__ \ "last_minted_at").read[_root_.java.time.OffsetDateTime]
      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(obj.mintedAt.toString),
      "last_minted_at" -> play.api.libs.json.JsString(obj.lastMintedAt.toString),
      "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_.java.time.OffsetDateTime]
      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(obj.blockTime.toString),
      "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_.java.time.OffsetDateTime]
      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(obj.mintedAt.toString),
      "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_.java.time.OffsetDateTime]
    } 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(obj.timestamp.toString)
    )
  }

  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)
      }
  }

}