/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.0.1-SNAPSHOT
 * User agent: apibuilder app.apibuilder.io/gimbalabs/hilltop-api/0.0.1-SNAPSHOT/http4s_0_15
 */
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_.java.time.Instant
  )

  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_.io.circe.Json] = 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_.java.time.Instant,
    endTime: _root_.java.time.Instant
  )

  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_.io.circe.Json,
    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_.io.circe.Json,
    mintedAt: _root_.java.time.Instant,
    lastMintedAt: _root_.java.time.Instant,
    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_.java.time.Instant,
    fingerprint: String
  )

  final case class NftDetails(
    policyId: String,
    assetNameRaw: String,
    assetName: _root_.scala.Option[String] = None,
    metadata: _root_.io.circe.Json,
    mintedAt: _root_.java.time.Instant,
    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_.java.time.Instant
  )

  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 io.circe.Decoder._
    import io.circe.Encoder._
    import scala.language.implicitConversions // See below - Make Scala 2.11 Either monadic
    import scala.util.Try
    import io.circe.{Json, JsonObject, Encoder, Decoder, DecodingFailure}
    import io.circe.syntax._
    import io.gimbalabs.hilltop.api.v0.models.json._

    // Make Scala 2.11 Either monadic
    private[v0] implicit def eitherOps[A,B](e: Either[A,B]) = cats.implicits.catsSyntaxEither(e)

    private[v0] implicit val decodeUUID: Decoder[_root_.java.util.UUID] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.util.UUID.fromString(str)))

    private[v0] implicit val encodeUUID: Encoder[_root_.java.util.UUID] =
      Encoder.encodeString.contramap[_root_.java.util.UUID](uuid => uuid.toString)

    private[v0] implicit val decodeInstant: Decoder[_root_.java.time.Instant] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.time.OffsetDateTime.parse(str).toInstant))

    private[v0] implicit val encodeInstant: Encoder[_root_.java.time.Instant] =
      Encoder.encodeString.contramap[_root_.java.time.Instant](_.toString)

    private[v0] implicit val decodeLocalDate: Decoder[_root_.java.time.LocalDate] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.time.LocalDate.parse(str)))

    private[v0] implicit val encodeLocalDate: Encoder[_root_.java.time.LocalDate] =
      Encoder.encodeString.contramap[_root_.java.time.LocalDate](_.toString)

    implicit val jsonDecoderHilltopApiCountry: Decoder[io.gimbalabs.hilltop.api.v0.models.Country] =
      Decoder.decodeString.map(io.gimbalabs.hilltop.api.v0.models.Country(_))

    implicit val jsonEncoderHilltopApiCountry: Encoder[io.gimbalabs.hilltop.api.v0.models.Country] =
      Encoder.encodeString.contramap[io.gimbalabs.hilltop.api.v0.models.Country](_.toString)

    implicit def decodeHilltopApiActiveStakeAmount: Decoder[ActiveStakeAmount] = Decoder.instance { c =>
     for {
        amountInLovelaces <- c.downField("amount_in_lovelaces").as[Long]
      } yield {
        ActiveStakeAmount(
          amountInLovelaces = amountInLovelaces
        )
      }
    }

    implicit def encodeHilltopApiActiveStakeAmount: Encoder[ActiveStakeAmount] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("amount_in_lovelaces" -> t.amountInLovelaces.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiAddressStakeAmount: Decoder[AddressStakeAmount] = Decoder.instance { c =>
     for {
        stakeAddress <- c.downField("stake_address").as[String]
        amountInLovelaces <- c.downField("amount_in_lovelaces").as[Long]
      } yield {
        AddressStakeAmount(
          stakeAddress = stakeAddress,
          amountInLovelaces = amountInLovelaces
        )
      }
    }

    implicit def encodeHilltopApiAddressStakeAmount: Encoder[AddressStakeAmount] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("stake_address" -> t.stakeAddress.asJson),
        Some("amount_in_lovelaces" -> t.amountInLovelaces.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiBlock: Decoder[Block] = Decoder.instance { c =>
     for {
        number <- c.downField("number").as[Long]
        epochNumber <- c.downField("epoch_number").as[Long]
        slotNumber <- c.downField("slot_number").as[Long]
        epochSlotNumber <- c.downField("epoch_slot_number").as[Long]
        size <- c.downField("size").as[Long]
        transactionCount <- c.downField("transaction_count").as[Long]
        time <- c.downField("time").as[_root_.java.time.Instant]
      } yield {
        Block(
          number = number,
          epochNumber = epochNumber,
          slotNumber = slotNumber,
          epochSlotNumber = epochSlotNumber,
          size = size,
          transactionCount = transactionCount,
          time = time
        )
      }
    }

    implicit def encodeHilltopApiBlock: Encoder[Block] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("number" -> t.number.asJson),
        Some("epoch_number" -> t.epochNumber.asJson),
        Some("slot_number" -> t.slotNumber.asJson),
        Some("epoch_slot_number" -> t.epochSlotNumber.asJson),
        Some("size" -> t.size.asJson),
        Some("transaction_count" -> t.transactionCount.asJson),
        Some("time" -> t.time.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiCnftMetadataV001: Decoder[CnftMetadataV001] = Decoder.instance { c =>
     for {
        policyId <- c.downField("policyId").as[String]
        tokens <- c.downField("tokens").as[Map[String, String]]
        asset <- c.downField("asset").as[io.gimbalabs.hilltop.api.v0.models.CnftMetadataV001Asset]
      } yield {
        CnftMetadataV001(
          policyId = policyId,
          tokens = tokens,
          asset = asset
        )
      }
    }

    implicit def encodeHilltopApiCnftMetadataV001: Encoder[CnftMetadataV001] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("policyId" -> t.policyId.asJson),
        Some("tokens" -> t.tokens.asJson),
        Some("asset" -> t.asset.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiCnftMetadataV001Asset: Decoder[CnftMetadataV001Asset] = Decoder.instance { c =>
     for {
        assetName <- c.downField("assetName").as[Option[String]]
        attributes <- c.downField("attributes").as[Option[_root_.io.circe.Json]]
        ipfs <- c.downField("ipfs").as[String]
        mimeType <- c.downField("mimeType").as[Option[String]]
      } yield {
        CnftMetadataV001Asset(
          assetName = assetName,
          attributes = attributes,
          ipfs = ipfs,
          mimeType = mimeType
        )
      }
    }

    implicit def encodeHilltopApiCnftMetadataV001Asset: Encoder[CnftMetadataV001Asset] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.assetName.map(t => "assetName" -> t.asJson),
        t.attributes.map(t => "attributes" -> t.asJson),
        Some("ipfs" -> t.ipfs.asJson),
        t.mimeType.map(t => "mimeType" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiDayBlock: Decoder[DayBlock] = Decoder.instance { c =>
     for {
        first <- c.downField("first").as[io.gimbalabs.hilltop.api.v0.models.Block]
        last <- c.downField("last").as[io.gimbalabs.hilltop.api.v0.models.Block]
      } yield {
        DayBlock(
          first = first,
          last = last
        )
      }
    }

    implicit def encodeHilltopApiDayBlock: Encoder[DayBlock] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("first" -> t.first.asJson),
        Some("last" -> t.last.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiDelegation: Decoder[Delegation] = Decoder.instance { c =>
     for {
        stakingAddress <- c.downField("staking_address").as[String]
        delegations <- c.downField("delegations").as[Seq[io.gimbalabs.hilltop.api.v0.models.StakepoolDelegation]]
      } yield {
        Delegation(
          stakingAddress = stakingAddress,
          delegations = delegations
        )
      }
    }

    implicit def encodeHilltopApiDelegation: Encoder[Delegation] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("staking_address" -> t.stakingAddress.asJson),
        Some("delegations" -> t.delegations.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiDelegatorsCount: Decoder[DelegatorsCount] = Decoder.instance { c =>
     for {
        delegatorsCountTotal <- c.downField("delegators_count_total").as[Int]
      } yield {
        DelegatorsCount(
          delegatorsCountTotal = delegatorsCountTotal
        )
      }
    }

    implicit def encodeHilltopApiDelegatorsCount: Encoder[DelegatorsCount] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("delegators_count_total" -> t.delegatorsCountTotal.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiEpoch: Decoder[Epoch] = Decoder.instance { c =>
     for {
        outSum <- c.downField("out_sum").as[Long]
        fees <- c.downField("fees").as[Long]
        txCount <- c.downField("tx_count").as[Int]
        blkCount <- c.downField("blk_count").as[Int]
        number <- c.downField("number").as[Int]
        startTime <- c.downField("start_time").as[_root_.java.time.Instant]
        endTime <- c.downField("end_time").as[_root_.java.time.Instant]
      } yield {
        Epoch(
          outSum = outSum,
          fees = fees,
          txCount = txCount,
          blkCount = blkCount,
          number = number,
          startTime = startTime,
          endTime = endTime
        )
      }
    }

    implicit def encodeHilltopApiEpoch: Encoder[Epoch] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("out_sum" -> t.outSum.asJson),
        Some("fees" -> t.fees.asJson),
        Some("tx_count" -> t.txCount.asJson),
        Some("blk_count" -> t.blkCount.asJson),
        Some("number" -> t.number.asJson),
        Some("start_time" -> t.startTime.asJson),
        Some("end_time" -> t.endTime.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiGenericError: Decoder[GenericError] = Decoder.instance { c =>
     for {
        description <- c.downField("description").as[String]
      } yield {
        GenericError(
          description = description
        )
      }
    }

    implicit def encodeHilltopApiGenericError: Encoder[GenericError] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("description" -> t.description.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiHealthcheck: Decoder[Healthcheck] = Decoder.instance { c =>
     for {
        status <- c.downField("status").as[String]
      } yield {
        Healthcheck(
          status = status
        )
      }
    }

    implicit def encodeHilltopApiHealthcheck: Encoder[Healthcheck] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("status" -> t.status.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNativeAsset: Decoder[NativeAsset] = Decoder.instance { c =>
     for {
        transactionId <- c.downField("transaction_id").as[String]
        policyId <- c.downField("policy_id").as[String]
        tokenName <- c.downField("token_name").as[String]
        metadata <- c.downField("metadata").as[_root_.io.circe.Json]
        blockNumber <- c.downField("block_number").as[Long]
        epochSlotNumber <- c.downField("epoch_slot_number").as[Long]
        epochNumber <- c.downField("epoch_number").as[Long]
        invalidBefore <- c.downField("invalid_before").as[Option[Long]]
        invalidHereafter <- c.downField("invalid_hereafter").as[Option[Long]]
        quantity <- c.downField("quantity").as[Long]
      } yield {
        NativeAsset(
          transactionId = transactionId,
          policyId = policyId,
          tokenName = tokenName,
          metadata = metadata,
          blockNumber = blockNumber,
          epochSlotNumber = epochSlotNumber,
          epochNumber = epochNumber,
          invalidBefore = invalidBefore,
          invalidHereafter = invalidHereafter,
          quantity = quantity
        )
      }
    }

    implicit def encodeHilltopApiNativeAsset: Encoder[NativeAsset] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("transaction_id" -> t.transactionId.asJson),
        Some("policy_id" -> t.policyId.asJson),
        Some("token_name" -> t.tokenName.asJson),
        Some("metadata" -> t.metadata.asJson),
        Some("block_number" -> t.blockNumber.asJson),
        Some("epoch_slot_number" -> t.epochSlotNumber.asJson),
        Some("epoch_number" -> t.epochNumber.asJson),
        t.invalidBefore.map(t => "invalid_before" -> t.asJson),
        t.invalidHereafter.map(t => "invalid_hereafter" -> t.asJson),
        Some("quantity" -> t.quantity.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNativeAssetDetails: Decoder[NativeAssetDetails] = Decoder.instance { c =>
     for {
        policyId <- c.downField("policy_id").as[String]
        assetName <- c.downField("asset_name").as[String]
        metadata <- c.downField("metadata").as[_root_.io.circe.Json]
        mintedAt <- c.downField("minted_at").as[_root_.java.time.Instant]
        lastMintedAt <- c.downField("last_minted_at").as[_root_.java.time.Instant]
        firstMintingTxBlock <- c.downField("first_minting_tx_block").as[Long]
        lastMintingTxBlock <- c.downField("last_minting_tx_block").as[Long]
        mintingTxHash <- c.downField("minting_tx_hash").as[String]
        circulatingSupply <- c.downField("circulating_supply").as[Long]
        fingerprint <- c.downField("fingerprint").as[String]
      } yield {
        NativeAssetDetails(
          policyId = policyId,
          assetName = assetName,
          metadata = metadata,
          mintedAt = mintedAt,
          lastMintedAt = lastMintedAt,
          firstMintingTxBlock = firstMintingTxBlock,
          lastMintingTxBlock = lastMintingTxBlock,
          mintingTxHash = mintingTxHash,
          circulatingSupply = circulatingSupply,
          fingerprint = fingerprint
        )
      }
    }

    implicit def encodeHilltopApiNativeAssetDetails: Encoder[NativeAssetDetails] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("policy_id" -> t.policyId.asJson),
        Some("asset_name" -> t.assetName.asJson),
        Some("metadata" -> t.metadata.asJson),
        Some("minted_at" -> t.mintedAt.asJson),
        Some("last_minted_at" -> t.lastMintedAt.asJson),
        Some("first_minting_tx_block" -> t.firstMintingTxBlock.asJson),
        Some("last_minting_tx_block" -> t.lastMintingTxBlock.asJson),
        Some("minting_tx_hash" -> t.mintingTxHash.asJson),
        Some("circulating_supply" -> t.circulatingSupply.asJson),
        Some("fingerprint" -> t.fingerprint.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNativeAssetDetailsRequest: Decoder[NativeAssetDetailsRequest] = Decoder.instance { c =>
     for {
        policyId <- c.downField("policy_id").as[String]
        assetNames <- c.downField("asset_names").as[Option[Seq[String]]]
      } yield {
        NativeAssetDetailsRequest(
          policyId = policyId,
          assetNames = assetNames
        )
      }
    }

    implicit def encodeHilltopApiNativeAssetDetailsRequest: Encoder[NativeAssetDetailsRequest] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("policy_id" -> t.policyId.asJson),
        t.assetNames.map(t => "asset_names" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNativeAssetId: Decoder[NativeAssetId] = Decoder.instance { c =>
     for {
        policyId <- c.downField("policy_id").as[String]
        assetName <- c.downField("asset_name").as[String]
        blockNumber <- c.downField("block_number").as[Long]
        blockTime <- c.downField("block_time").as[_root_.java.time.Instant]
        fingerprint <- c.downField("fingerprint").as[String]
      } yield {
        NativeAssetId(
          policyId = policyId,
          assetName = assetName,
          blockNumber = blockNumber,
          blockTime = blockTime,
          fingerprint = fingerprint
        )
      }
    }

    implicit def encodeHilltopApiNativeAssetId: Encoder[NativeAssetId] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("policy_id" -> t.policyId.asJson),
        Some("asset_name" -> t.assetName.asJson),
        Some("block_number" -> t.blockNumber.asJson),
        Some("block_time" -> t.blockTime.asJson),
        Some("fingerprint" -> t.fingerprint.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNftDetails: Decoder[NftDetails] = Decoder.instance { c =>
     for {
        policyId <- c.downField("policy_id").as[String]
        assetNameRaw <- c.downField("asset_name_raw").as[String]
        assetName <- c.downField("asset_name").as[Option[String]]
        metadata <- c.downField("metadata").as[_root_.io.circe.Json]
        mintedAt <- c.downField("minted_at").as[_root_.java.time.Instant]
        mintedAtBlock <- c.downField("minted_at_block").as[Long]
        mintingTxHash <- c.downField("minting_tx_hash").as[String]
        amount <- c.downField("amount").as[Long]
        fingerprint <- c.downField("fingerprint").as[String]
      } yield {
        NftDetails(
          policyId = policyId,
          assetNameRaw = assetNameRaw,
          assetName = assetName,
          metadata = metadata,
          mintedAt = mintedAt,
          mintedAtBlock = mintedAtBlock,
          mintingTxHash = mintingTxHash,
          amount = amount,
          fingerprint = fingerprint
        )
      }
    }

    implicit def encodeHilltopApiNftDetails: Encoder[NftDetails] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("policy_id" -> t.policyId.asJson),
        Some("asset_name_raw" -> t.assetNameRaw.asJson),
        t.assetName.map(t => "asset_name" -> t.asJson),
        Some("metadata" -> t.metadata.asJson),
        Some("minted_at" -> t.mintedAt.asJson),
        Some("minted_at_block" -> t.mintedAtBlock.asJson),
        Some("minting_tx_hash" -> t.mintingTxHash.asJson),
        Some("amount" -> t.amount.asJson),
        Some("fingerprint" -> t.fingerprint.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNftMetadata: Decoder[NftMetadata] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[Option[String]]
        image <- c.downField("image").as[Option[String]]
        mediaType <- c.downField("mediaType").as[Option[String]]
        files <- c.downField("files").as[Option[Seq[io.gimbalabs.hilltop.api.v0.models.NftMetadataFile]]]
      } yield {
        NftMetadata(
          name = name,
          image = image,
          mediaType = mediaType,
          files = files
        )
      }
    }

    implicit def encodeHilltopApiNftMetadata: Encoder[NftMetadata] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.name.map(t => "name" -> t.asJson),
        t.image.map(t => "image" -> t.asJson),
        t.mediaType.map(t => "mediaType" -> t.asJson),
        t.files.map(t => "files" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNftMetadataFile: Decoder[NftMetadataFile] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[Option[String]]
        src <- c.downField("src").as[Option[String]]
        mediaType <- c.downField("mediaType").as[Option[String]]
      } yield {
        NftMetadataFile(
          name = name,
          src = src,
          mediaType = mediaType
        )
      }
    }

    implicit def encodeHilltopApiNftMetadataFile: Encoder[NftMetadataFile] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.name.map(t => "name" -> t.asJson),
        t.src.map(t => "src" -> t.asJson),
        t.mediaType.map(t => "mediaType" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNftMetadataFilesAsObject: Decoder[NftMetadataFilesAsObject] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[Option[String]]
        image <- c.downField("image").as[Option[String]]
        mediaType <- c.downField("mediaType").as[Option[String]]
        files <- c.downField("files").as[Option[io.gimbalabs.hilltop.api.v0.models.NftMetadataFile]]
      } yield {
        NftMetadataFilesAsObject(
          name = name,
          image = image,
          mediaType = mediaType,
          files = files
        )
      }
    }

    implicit def encodeHilltopApiNftMetadataFilesAsObject: Encoder[NftMetadataFilesAsObject] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.name.map(t => "name" -> t.asJson),
        t.image.map(t => "image" -> t.asJson),
        t.mediaType.map(t => "mediaType" -> t.asJson),
        t.files.map(t => "files" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNftMetadataImgArray: Decoder[NftMetadataImgArray] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[Option[String]]
        image <- c.downField("image").as[Option[Seq[String]]]
        mediaType <- c.downField("mediaType").as[Option[String]]
        files <- c.downField("files").as[Option[Seq[io.gimbalabs.hilltop.api.v0.models.NftMetadataFile]]]
      } yield {
        NftMetadataImgArray(
          name = name,
          image = image,
          mediaType = mediaType,
          files = files
        )
      }
    }

    implicit def encodeHilltopApiNftMetadataImgArray: Encoder[NftMetadataImgArray] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.name.map(t => "name" -> t.asJson),
        t.image.map(t => "image" -> t.asJson),
        t.mediaType.map(t => "mediaType" -> t.asJson),
        t.files.map(t => "files" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNftMetadataNoFiles: Decoder[NftMetadataNoFiles] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[Option[String]]
        image <- c.downField("image").as[Option[String]]
        mediaType <- c.downField("mediaType").as[Option[String]]
      } yield {
        NftMetadataNoFiles(
          name = name,
          image = image,
          mediaType = mediaType
        )
      }
    }

    implicit def encodeHilltopApiNftMetadataNoFiles: Encoder[NftMetadataNoFiles] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.name.map(t => "name" -> t.asJson),
        t.image.map(t => "image" -> t.asJson),
        t.mediaType.map(t => "mediaType" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiPoolRetiring: Decoder[PoolRetiring] = Decoder.instance { c =>
     for {
        tickerName <- c.downField("ticker_name").as[Option[String]]
        poolId <- c.downField("pool_id").as[String]
        certificateIndex <- c.downField("certificate_index").as[Int]
        epochNumber <- c.downField("epoch_number").as[Long]
        blockNumber <- c.downField("block_number").as[Long]
        retiringAtEpoch <- c.downField("retiring_at_epoch").as[Long]
        txHash <- c.downField("tx_hash").as[String]
      } yield {
        PoolRetiring(
          tickerName = tickerName,
          poolId = poolId,
          certificateIndex = certificateIndex,
          epochNumber = epochNumber,
          blockNumber = blockNumber,
          retiringAtEpoch = retiringAtEpoch,
          txHash = txHash
        )
      }
    }

    implicit def encodeHilltopApiPoolRetiring: Encoder[PoolRetiring] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.tickerName.map(t => "ticker_name" -> t.asJson),
        Some("pool_id" -> t.poolId.asJson),
        Some("certificate_index" -> t.certificateIndex.asJson),
        Some("epoch_number" -> t.epochNumber.asJson),
        Some("block_number" -> t.blockNumber.asJson),
        Some("retiring_at_epoch" -> t.retiringAtEpoch.asJson),
        Some("tx_hash" -> t.txHash.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiPoolUpdate: Decoder[PoolUpdate] = Decoder.instance { c =>
     for {
        epochNumber <- c.downField("epoch_number").as[Int]
        blockNumber <- c.downField("block_number").as[Long]
        txHash <- c.downField("tx_hash").as[String]
        poolTickerName <- c.downField("pool_ticker_name").as[Option[String]]
        poolBech32Id <- c.downField("pool_bech32_id").as[String]
        certificateIndex <- c.downField("certificate_index").as[Int]
        vrfKeyHash <- c.downField("vrf_key_hash").as[String]
        pledge <- c.downField("pledge").as[Long]
        rewardAddress <- c.downField("reward_address").as[String]
        activeEpochNumber <- c.downField("active_epoch_number").as[Long]
        margin <- c.downField("margin").as[Double]
        fixedCost <- c.downField("fixed_cost").as[Long]
      } yield {
        PoolUpdate(
          epochNumber = epochNumber,
          blockNumber = blockNumber,
          txHash = txHash,
          poolTickerName = poolTickerName,
          poolBech32Id = poolBech32Id,
          certificateIndex = certificateIndex,
          vrfKeyHash = vrfKeyHash,
          pledge = pledge,
          rewardAddress = rewardAddress,
          activeEpochNumber = activeEpochNumber,
          margin = margin,
          fixedCost = fixedCost
        )
      }
    }

    implicit def encodeHilltopApiPoolUpdate: Encoder[PoolUpdate] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("epoch_number" -> t.epochNumber.asJson),
        Some("block_number" -> t.blockNumber.asJson),
        Some("tx_hash" -> t.txHash.asJson),
        t.poolTickerName.map(t => "pool_ticker_name" -> t.asJson),
        Some("pool_bech32_id" -> t.poolBech32Id.asJson),
        Some("certificate_index" -> t.certificateIndex.asJson),
        Some("vrf_key_hash" -> t.vrfKeyHash.asJson),
        Some("pledge" -> t.pledge.asJson),
        Some("reward_address" -> t.rewardAddress.asJson),
        Some("active_epoch_number" -> t.activeEpochNumber.asJson),
        Some("margin" -> t.margin.asJson),
        Some("fixed_cost" -> t.fixedCost.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiReward: Decoder[Reward] = Decoder.instance { c =>
     for {
        stakingAddress <- c.downField("staking_address").as[String]
        epoch <- c.downField("epoch").as[Int]
        amount <- c.downField("amount").as[Long]
        poolId <- c.downField("pool_id").as[String]
      } yield {
        Reward(
          stakingAddress = stakingAddress,
          epoch = epoch,
          amount = amount,
          poolId = poolId
        )
      }
    }

    implicit def encodeHilltopApiReward: Encoder[Reward] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("staking_address" -> t.stakingAddress.asJson),
        Some("epoch" -> t.epoch.asJson),
        Some("amount" -> t.amount.asJson),
        Some("pool_id" -> t.poolId.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiSigma: Decoder[Sigma] = Decoder.instance { c =>
     for {
        sigma <- c.downField("sigma").as[Double]
        epoch <- c.downField("epoch").as[Int]
        totalStaked <- c.downField("total_staked").as[Long]
        activeStake <- c.downField("active_stake").as[Long]
        nonce <- c.downField("nonce").as[String]
        d <- c.downField("d").as[Double]
      } yield {
        Sigma(
          sigma = sigma,
          epoch = epoch,
          totalStaked = totalStaked,
          activeStake = activeStake,
          nonce = nonce,
          d = d
        )
      }
    }

    implicit def encodeHilltopApiSigma: Encoder[Sigma] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("sigma" -> t.sigma.asJson),
        Some("epoch" -> t.epoch.asJson),
        Some("total_staked" -> t.totalStaked.asJson),
        Some("active_stake" -> t.activeStake.asJson),
        Some("nonce" -> t.nonce.asJson),
        Some("d" -> t.d.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiStakepool: Decoder[Stakepool] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        poolIdBech32 <- c.downField("pool_id_bech32").as[String]
        metadata <- c.downField("metadata").as[Option[io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata]]
        cost <- c.downField("cost").as[Long]
        margin <- c.downField("margin").as[Double]
        pledge <- c.downField("pledge").as[Long]
        activeStake <- c.downField("active_stake").as[Long]
        saturation <- c.downField("saturation").as[Double]
        retiringAtEpoch <- c.downField("retiring_at_epoch").as[Option[Long]]
      } yield {
        Stakepool(
          id = id,
          poolIdBech32 = poolIdBech32,
          metadata = metadata,
          cost = cost,
          margin = margin,
          pledge = pledge,
          activeStake = activeStake,
          saturation = saturation,
          retiringAtEpoch = retiringAtEpoch
        )
      }
    }

    implicit def encodeHilltopApiStakepool: Encoder[Stakepool] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("pool_id_bech32" -> t.poolIdBech32.asJson),
        t.metadata.map(t => "metadata" -> t.asJson),
        Some("cost" -> t.cost.asJson),
        Some("margin" -> t.margin.asJson),
        Some("pledge" -> t.pledge.asJson),
        Some("active_stake" -> t.activeStake.asJson),
        Some("saturation" -> t.saturation.asJson),
        t.retiringAtEpoch.map(t => "retiring_at_epoch" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiStakepoolDelegation: Decoder[StakepoolDelegation] = Decoder.instance { c =>
     for {
        stakepool <- c.downField("stakepool").as[io.gimbalabs.hilltop.api.v0.models.Stakepool]
        epoch <- c.downField("epoch").as[Int]
      } yield {
        StakepoolDelegation(
          stakepool = stakepool,
          epoch = epoch
        )
      }
    }

    implicit def encodeHilltopApiStakepoolDelegation: Encoder[StakepoolDelegation] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("stakepool" -> t.stakepool.asJson),
        Some("epoch" -> t.epoch.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiStakepoolMetadata: Decoder[StakepoolMetadata] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        ticker <- c.downField("ticker").as[String]
        homepage <- c.downField("homepage").as[String]
        description <- c.downField("description").as[String]
        extended <- c.downField("extended").as[Option[String]]
      } yield {
        StakepoolMetadata(
          name = name,
          ticker = ticker,
          homepage = homepage,
          description = description,
          extended = extended
        )
      }
    }

    implicit def encodeHilltopApiStakepoolMetadata: Encoder[StakepoolMetadata] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("ticker" -> t.ticker.asJson),
        Some("homepage" -> t.homepage.asJson),
        Some("description" -> t.description.asJson),
        t.extended.map(t => "extended" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiTransaction: Decoder[Transaction] = Decoder.instance { c =>
     for {
        hash <- c.downField("hash").as[String]
        block <- c.downField("block").as[Long]
        timestamp <- c.downField("timestamp").as[_root_.java.time.Instant]
      } yield {
        Transaction(
          hash = hash,
          block = block,
          timestamp = timestamp
        )
      }
    }

    implicit def encodeHilltopApiTransaction: Encoder[Transaction] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("hash" -> t.hash.asJson),
        Some("block" -> t.block.asJson),
        Some("timestamp" -> t.timestamp.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiTransactionHistoryRequest: Decoder[TransactionHistoryRequest] = Decoder.instance { c =>
     for {
        addresses <- c.downField("addresses").as[Seq[String]]
      } yield {
        TransactionHistoryRequest(
          addresses = addresses
        )
      }
    }

    implicit def encodeHilltopApiTransactionHistoryRequest: Encoder[TransactionHistoryRequest] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("addresses" -> t.addresses.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiWalletBalance: Decoder[WalletBalance] = Decoder.instance { c =>
     for {
        balance <- c.downField("balance").as[Long]
      } yield {
        WalletBalance(
          balance = balance
        )
      }
    }

    implicit def encodeHilltopApiWalletBalance: Encoder[WalletBalance] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("balance" -> t.balance.asJson)
      ).flatten)
    }
  }
}

package io.gimbalabs.hilltop.api.v0 {
import org.http4s.client.blaze._
import io.circe.syntax._

  object Constants {

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

  }

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

def closeAsyncHttpClient(): Unit = {
  asyncHttpClient.shutdownNow()
}

    def activeStakeAmounts: ActiveStakeAmounts = ActiveStakeAmounts

    def blocks: Blocks = Blocks

    def delegations: Delegations = Delegations

    def delegatorsCounts: DelegatorsCounts = DelegatorsCounts

    def epochs: Epochs = Epochs

    def healthchecks: Healthchecks = Healthchecks

    def nativeAssets: NativeAssets = NativeAssets

    def poolUpdates: PoolUpdates = PoolUpdates

    def rewards: Rewards = Rewards

    def sigmas: Sigmas = Sigmas

    def stakepoolMetadata: StakepoolMetadata = StakepoolMetadata

    def stakepools: Stakepools = Stakepools

    def transactions: Transactions = Transactions

    def walletBalances: WalletBalances = WalletBalances

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

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

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

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

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

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

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

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

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

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

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

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.DayBlock]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[io.gimbalabs.hilltop.api.v0.models.DayBlock]("io.gimbalabs.hilltop.api.v0.models.DayBlock", r)
          case r if r.status.code == 404 => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r))
          case r => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }

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

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.Block]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[io.gimbalabs.hilltop.api.v0.models.Block]("io.gimbalabs.hilltop.api.v0.models.Block", r)
          case r if r.status.code == 404 => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r))
          case r => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }
    }

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

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

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

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.Delegation]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[io.gimbalabs.hilltop.api.v0.models.Delegation]("io.gimbalabs.hilltop.api.v0.models.Delegation", r)
          case r if r.status.code == 404 => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r))
          case r => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _executeRequest[Unit, Seq[io.gimbalabs.hilltop.api.v0.models.NftDetails]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[Seq[io.gimbalabs.hilltop.api.v0.models.NftDetails]]("Seq[io.gimbalabs.hilltop.api.v0.models.NftDetails]", r)
          case r if r.status.code == 404 => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r))
          case r => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }

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

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

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

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

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

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

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

        _executeRequest[Unit, Seq[io.gimbalabs.hilltop.api.v0.models.PoolRetiring]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[Seq[io.gimbalabs.hilltop.api.v0.models.PoolRetiring]]("Seq[io.gimbalabs.hilltop.api.v0.models.PoolRetiring]", r)
          case r if r.status.code == 404 => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r))
          case r => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }

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

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

        _executeRequest[Unit, Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]]("Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]", r)
          case r if r.status.code == 404 => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r))
          case r => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }

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

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

        _executeRequest[Unit, Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]]("Seq[io.gimbalabs.hilltop.api.v0.models.PoolUpdate]", r)
          case r if r.status.code == 404 => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r))
          case r => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }
    }

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

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

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

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

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

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

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

        _executeRequest[Unit, io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata]("io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata", r)
          case r if r.status.code == 404 => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r))
          case r => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }
    }

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

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

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

        _executeRequest[Unit, Int]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[Int]("Int", r)
          case r if r.status.code == 404 => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r))
          case r => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }

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

        _executeRequest[Unit, Long]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[Long]("Long", r)
          case r if r.status.code == 404 => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r))
          case r => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }

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

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

        _executeRequest[Unit, Int]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.gimbalabs.hilltop.api.v0.Client.parseJson[Int]("Int", r)
          case r if r.status.code == 404 => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.GenericErrorResponse(r))
          case r => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 404"))
        }
      }

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

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

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

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

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

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

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

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

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

    def modifyRequest(request: scalaz.concurrent.Task[org.http4s.Request]): scalaz.concurrent.Task[org.http4s.Request] = request

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

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

      val m = org.http4s.Method.fromString(method) match {
        case scalaz.\/-(m) => m
        case scalaz.-\/(e) => sys.error(e.toString)
      }

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

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

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

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

      val reqAndMaybeAuthAndBody =
        if (formBody.nonEmpty) formBody.fold(scalaz.concurrent.Task.now(reqAndMaybeAuth))(reqAndMaybeAuth.withBody)
        else body.fold(scalaz.concurrent.Task.now(reqAndMaybeAuth))(reqAndMaybeAuth.withBody)

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

  object Client {



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

    private lazy val defaultAsyncHttpClient = PooledHttp1Client()

    def parseJson[T](
      className: String,
      r: org.http4s.Response
    )(implicit decoder: io.circe.Decoder[T]): scalaz.concurrent.Task[T] = r.attemptAs[T].run.flatMap {
      case scalaz.\/-(value) => scalaz.concurrent.Task.now(value)
      case scalaz.-\/(error) => scalaz.concurrent.Task.fail(new io.gimbalabs.hilltop.api.v0.errors.FailedRequest(r.status.code, s"Invalid json for class[" + className + "]", None, error))
    }
  }

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

  package interfaces {

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

  }

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

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

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

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

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

  trait Delegations {
    def getSafePaymentByStakingAddress(
      stakingAddress: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): scalaz.concurrent.Task[String]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  package errors {

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

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

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

  }
}