• Home
• kr.jadekim
• chameleon-proto-terra-classic-core-jvm
• 3.0.1-3
• source code
• query.kt

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

commonMain.terra.oracle.v1beta1.query.kt Maven / Gradle / Ivy

// Transform from terra/oracle/v1beta1/query.proto
@file:GeneratorVersion(version = "0.5.2")

package terra.oracle.v1beta1

import cosmos.base.v1beta1.DecCoin
import kotlin.OptIn
import kotlin.String
import kotlin.ULong
import kotlin.collections.List
import kotlin.collections.emptyList
import kotlinx.serialization.ExperimentalSerializationApi
import kotlinx.serialization.KSerializer
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
import kotlinx.serialization.Serializer
import kotlinx.serialization.descriptors.SerialDescriptor
import kotlinx.serialization.encoding.Decoder
import kotlinx.serialization.encoding.Encoder
import kr.jadekim.protobuf.`annotation`.GeneratorVersion
import kr.jadekim.protobuf.`annotation`.ProtobufIndex
import kr.jadekim.protobuf.kotlinx.ProtobufConverterDecoder
import kr.jadekim.protobuf.kotlinx.ProtobufConverterEncoder
import kr.jadekim.protobuf.type.ProtobufService
import kr.jadekim.protobuf.`annotation`.ProtobufMessage as AnnotationProtobufMessage
import kr.jadekim.protobuf.type.ProtobufMessage as TypeProtobufMessage

@AnnotationProtobufMessage(typeUrl = QueryExchangeRateRequest.TYPE_URL)
@Serializable(with = QueryExchangeRateRequest.KotlinxSerializer::class)
@SerialName(value = QueryExchangeRateRequest.TYPE_URL)
public data class QueryExchangeRateRequest(
  @ProtobufIndex(index = 1)
  public val denom: String = "",
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryExchangeRateRequest"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryExchangeRateRequest::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryExchangeRateRequest) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryExchangeRateRequestConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryExchangeRateRequest {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryExchangeRateRequestConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryExchangeRateResponse.TYPE_URL)
@Serializable(with = QueryExchangeRateResponse.KotlinxSerializer::class)
@SerialName(value = QueryExchangeRateResponse.TYPE_URL)
public data class QueryExchangeRateResponse(
  @ProtobufIndex(index = 1)
  public val exchangeRate: String = "",
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryExchangeRateResponse"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryExchangeRateResponse::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryExchangeRateResponse) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryExchangeRateResponseConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryExchangeRateResponse {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryExchangeRateResponseConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryExchangeRatesRequest.TYPE_URL)
@Serializable(with = QueryExchangeRatesRequest.KotlinxSerializer::class)
@SerialName(value = QueryExchangeRatesRequest.TYPE_URL)
public class QueryExchangeRatesRequest() : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryExchangeRatesRequest"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryExchangeRatesRequest::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryExchangeRatesRequest) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryExchangeRatesRequestConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryExchangeRatesRequest {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryExchangeRatesRequestConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryExchangeRatesResponse.TYPE_URL)
@Serializable(with = QueryExchangeRatesResponse.KotlinxSerializer::class)
@SerialName(value = QueryExchangeRatesResponse.TYPE_URL)
public data class QueryExchangeRatesResponse(
  @ProtobufIndex(index = 1)
  public val exchangeRates: List = emptyList(),
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryExchangeRatesResponse"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryExchangeRatesResponse::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryExchangeRatesResponse) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryExchangeRatesResponseConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryExchangeRatesResponse {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryExchangeRatesResponseConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryTobinTaxRequest.TYPE_URL)
@Serializable(with = QueryTobinTaxRequest.KotlinxSerializer::class)
@SerialName(value = QueryTobinTaxRequest.TYPE_URL)
public data class QueryTobinTaxRequest(
  @ProtobufIndex(index = 1)
  public val denom: String = "",
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryTobinTaxRequest"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryTobinTaxRequest::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryTobinTaxRequest) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryTobinTaxRequestConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryTobinTaxRequest {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryTobinTaxRequestConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryTobinTaxResponse.TYPE_URL)
@Serializable(with = QueryTobinTaxResponse.KotlinxSerializer::class)
@SerialName(value = QueryTobinTaxResponse.TYPE_URL)
public data class QueryTobinTaxResponse(
  @ProtobufIndex(index = 1)
  public val tobinTax: String = "",
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryTobinTaxResponse"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryTobinTaxResponse::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryTobinTaxResponse) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryTobinTaxResponseConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryTobinTaxResponse {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryTobinTaxResponseConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryTobinTaxesRequest.TYPE_URL)
@Serializable(with = QueryTobinTaxesRequest.KotlinxSerializer::class)
@SerialName(value = QueryTobinTaxesRequest.TYPE_URL)
public class QueryTobinTaxesRequest() : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryTobinTaxesRequest"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryTobinTaxesRequest::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryTobinTaxesRequest) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryTobinTaxesRequestConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryTobinTaxesRequest {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryTobinTaxesRequestConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryTobinTaxesResponse.TYPE_URL)
@Serializable(with = QueryTobinTaxesResponse.KotlinxSerializer::class)
@SerialName(value = QueryTobinTaxesResponse.TYPE_URL)
public data class QueryTobinTaxesResponse(
  @ProtobufIndex(index = 1)
  public val tobinTaxes: List = emptyList(),
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryTobinTaxesResponse"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryTobinTaxesResponse::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryTobinTaxesResponse) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryTobinTaxesResponseConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryTobinTaxesResponse {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryTobinTaxesResponseConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryActivesRequest.TYPE_URL)
@Serializable(with = QueryActivesRequest.KotlinxSerializer::class)
@SerialName(value = QueryActivesRequest.TYPE_URL)
public class QueryActivesRequest() : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryActivesRequest"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryActivesRequest::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryActivesRequest) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryActivesRequestConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryActivesRequest {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryActivesRequestConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryActivesResponse.TYPE_URL)
@Serializable(with = QueryActivesResponse.KotlinxSerializer::class)
@SerialName(value = QueryActivesResponse.TYPE_URL)
public data class QueryActivesResponse(
  @ProtobufIndex(index = 1)
  public val actives: List = emptyList(),
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryActivesResponse"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryActivesResponse::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryActivesResponse) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryActivesResponseConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryActivesResponse {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryActivesResponseConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryVoteTargetsRequest.TYPE_URL)
@Serializable(with = QueryVoteTargetsRequest.KotlinxSerializer::class)
@SerialName(value = QueryVoteTargetsRequest.TYPE_URL)
public class QueryVoteTargetsRequest() : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryVoteTargetsRequest"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryVoteTargetsRequest::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryVoteTargetsRequest) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryVoteTargetsRequestConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryVoteTargetsRequest {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryVoteTargetsRequestConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryVoteTargetsResponse.TYPE_URL)
@Serializable(with = QueryVoteTargetsResponse.KotlinxSerializer::class)
@SerialName(value = QueryVoteTargetsResponse.TYPE_URL)
public data class QueryVoteTargetsResponse(
  @ProtobufIndex(index = 1)
  public val voteTargets: List = emptyList(),
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryVoteTargetsResponse"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryVoteTargetsResponse::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryVoteTargetsResponse) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryVoteTargetsResponseConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryVoteTargetsResponse {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryVoteTargetsResponseConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryFeederDelegationRequest.TYPE_URL)
@Serializable(with = QueryFeederDelegationRequest.KotlinxSerializer::class)
@SerialName(value = QueryFeederDelegationRequest.TYPE_URL)
public data class QueryFeederDelegationRequest(
  @ProtobufIndex(index = 1)
  public val validatorAddr: String = "",
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryFeederDelegationRequest"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryFeederDelegationRequest::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryFeederDelegationRequest) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryFeederDelegationRequestConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryFeederDelegationRequest {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryFeederDelegationRequestConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryFeederDelegationResponse.TYPE_URL)
@Serializable(with = QueryFeederDelegationResponse.KotlinxSerializer::class)
@SerialName(value = QueryFeederDelegationResponse.TYPE_URL)
public data class QueryFeederDelegationResponse(
  @ProtobufIndex(index = 1)
  public val feederAddr: String = "",
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryFeederDelegationResponse"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryFeederDelegationResponse::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryFeederDelegationResponse) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryFeederDelegationResponseConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryFeederDelegationResponse {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryFeederDelegationResponseConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryMissCounterRequest.TYPE_URL)
@Serializable(with = QueryMissCounterRequest.KotlinxSerializer::class)
@SerialName(value = QueryMissCounterRequest.TYPE_URL)
public data class QueryMissCounterRequest(
  @ProtobufIndex(index = 1)
  public val validatorAddr: String = "",
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryMissCounterRequest"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryMissCounterRequest::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryMissCounterRequest) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryMissCounterRequestConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryMissCounterRequest {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryMissCounterRequestConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryMissCounterResponse.TYPE_URL)
@Serializable(with = QueryMissCounterResponse.KotlinxSerializer::class)
@SerialName(value = QueryMissCounterResponse.TYPE_URL)
public data class QueryMissCounterResponse(
  @ProtobufIndex(index = 1)
  public val missCounter: ULong = 0uL,
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryMissCounterResponse"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryMissCounterResponse::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryMissCounterResponse) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryMissCounterResponseConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryMissCounterResponse {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryMissCounterResponseConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryAggregatePrevoteRequest.TYPE_URL)
@Serializable(with = QueryAggregatePrevoteRequest.KotlinxSerializer::class)
@SerialName(value = QueryAggregatePrevoteRequest.TYPE_URL)
public data class QueryAggregatePrevoteRequest(
  @ProtobufIndex(index = 1)
  public val validatorAddr: String = "",
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryAggregatePrevoteRequest"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryAggregatePrevoteRequest::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryAggregatePrevoteRequest) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryAggregatePrevoteRequestConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryAggregatePrevoteRequest {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryAggregatePrevoteRequestConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryAggregatePrevoteResponse.TYPE_URL)
@Serializable(with = QueryAggregatePrevoteResponse.KotlinxSerializer::class)
@SerialName(value = QueryAggregatePrevoteResponse.TYPE_URL)
public data class QueryAggregatePrevoteResponse(
  @ProtobufIndex(index = 1)
  public val aggregatePrevote: AggregateExchangeRatePrevote = AggregateExchangeRatePrevote(),
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryAggregatePrevoteResponse"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryAggregatePrevoteResponse::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryAggregatePrevoteResponse) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryAggregatePrevoteResponseConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryAggregatePrevoteResponse {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryAggregatePrevoteResponseConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryAggregatePrevotesRequest.TYPE_URL)
@Serializable(with = QueryAggregatePrevotesRequest.KotlinxSerializer::class)
@SerialName(value = QueryAggregatePrevotesRequest.TYPE_URL)
public class QueryAggregatePrevotesRequest() : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryAggregatePrevotesRequest"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryAggregatePrevotesRequest::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryAggregatePrevotesRequest) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryAggregatePrevotesRequestConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryAggregatePrevotesRequest {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryAggregatePrevotesRequestConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryAggregatePrevotesResponse.TYPE_URL)
@Serializable(with = QueryAggregatePrevotesResponse.KotlinxSerializer::class)
@SerialName(value = QueryAggregatePrevotesResponse.TYPE_URL)
public data class QueryAggregatePrevotesResponse(
  @ProtobufIndex(index = 1)
  public val aggregatePrevotes: List = emptyList(),
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryAggregatePrevotesResponse"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryAggregatePrevotesResponse::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryAggregatePrevotesResponse) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryAggregatePrevotesResponseConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryAggregatePrevotesResponse {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryAggregatePrevotesResponseConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryAggregateVoteRequest.TYPE_URL)
@Serializable(with = QueryAggregateVoteRequest.KotlinxSerializer::class)
@SerialName(value = QueryAggregateVoteRequest.TYPE_URL)
public data class QueryAggregateVoteRequest(
  @ProtobufIndex(index = 1)
  public val validatorAddr: String = "",
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryAggregateVoteRequest"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryAggregateVoteRequest::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryAggregateVoteRequest) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryAggregateVoteRequestConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryAggregateVoteRequest {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryAggregateVoteRequestConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryAggregateVoteResponse.TYPE_URL)
@Serializable(with = QueryAggregateVoteResponse.KotlinxSerializer::class)
@SerialName(value = QueryAggregateVoteResponse.TYPE_URL)
public data class QueryAggregateVoteResponse(
  @ProtobufIndex(index = 1)
  public val aggregateVote: AggregateExchangeRateVote = AggregateExchangeRateVote(),
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryAggregateVoteResponse"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryAggregateVoteResponse::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryAggregateVoteResponse) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryAggregateVoteResponseConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryAggregateVoteResponse {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryAggregateVoteResponseConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryAggregateVotesRequest.TYPE_URL)
@Serializable(with = QueryAggregateVotesRequest.KotlinxSerializer::class)
@SerialName(value = QueryAggregateVotesRequest.TYPE_URL)
public class QueryAggregateVotesRequest() : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryAggregateVotesRequest"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryAggregateVotesRequest::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryAggregateVotesRequest) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryAggregateVotesRequestConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryAggregateVotesRequest {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryAggregateVotesRequestConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryAggregateVotesResponse.TYPE_URL)
@Serializable(with = QueryAggregateVotesResponse.KotlinxSerializer::class)
@SerialName(value = QueryAggregateVotesResponse.TYPE_URL)
public data class QueryAggregateVotesResponse(
  @ProtobufIndex(index = 1)
  public val aggregateVotes: List = emptyList(),
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryAggregateVotesResponse"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryAggregateVotesResponse::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryAggregateVotesResponse) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryAggregateVotesResponseConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryAggregateVotesResponse {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryAggregateVotesResponseConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryParamsRequest.TYPE_URL)
@Serializable(with = QueryParamsRequest.KotlinxSerializer::class)
@SerialName(value = QueryParamsRequest.TYPE_URL)
public class QueryParamsRequest() : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryParamsRequest"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryParamsRequest::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryParamsRequest) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryParamsRequestConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryParamsRequest {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryParamsRequestConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

@AnnotationProtobufMessage(typeUrl = QueryParamsResponse.TYPE_URL)
@Serializable(with = QueryParamsResponse.KotlinxSerializer::class)
@SerialName(value = QueryParamsResponse.TYPE_URL)
public data class QueryParamsResponse(
  @ProtobufIndex(index = 1)
  public val params: Params = Params(),
) : TypeProtobufMessage {
  public companion object {
    public const val TYPE_URL: String = "/terra.oracle.v1beta1.QueryParamsResponse"
  }

  @OptIn(ExperimentalSerializationApi::class)
  @Serializer(forClass = QueryParamsResponse::class)
  private object ReflectSerializer

  public object KotlinxSerializer : KSerializer {
    private val delegator: KSerializer = ReflectSerializer

    override val descriptor: SerialDescriptor = delegator.descriptor

    override fun serialize(encoder: Encoder, `value`: QueryParamsResponse) {
      if (encoder is ProtobufConverterEncoder) {
        encoder.serialize(QueryParamsResponseConverter, value)
        return
      }
      delegator.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): QueryParamsResponse {
      if (decoder is ProtobufConverterDecoder) {
        return decoder.deserialize(QueryParamsResponseConverter)
      }
      return delegator.deserialize(decoder)
    }
  }
}

public interface Query : ProtobufService {
  public suspend fun exchangeRate(request: QueryExchangeRateRequest): QueryExchangeRateResponse

  public suspend fun exchangeRates(request: QueryExchangeRatesRequest): QueryExchangeRatesResponse

  public suspend fun tobinTax(request: QueryTobinTaxRequest): QueryTobinTaxResponse

  public suspend fun tobinTaxes(request: QueryTobinTaxesRequest): QueryTobinTaxesResponse

  public suspend fun actives(request: QueryActivesRequest): QueryActivesResponse

  public suspend fun voteTargets(request: QueryVoteTargetsRequest): QueryVoteTargetsResponse

  public suspend fun feederDelegation(request: QueryFeederDelegationRequest):
      QueryFeederDelegationResponse

  public suspend fun missCounter(request: QueryMissCounterRequest): QueryMissCounterResponse

  public suspend fun aggregatePrevote(request: QueryAggregatePrevoteRequest):
      QueryAggregatePrevoteResponse

  public suspend fun aggregatePrevotes(request: QueryAggregatePrevotesRequest):
      QueryAggregatePrevotesResponse

  public suspend fun aggregateVote(request: QueryAggregateVoteRequest): QueryAggregateVoteResponse

  public suspend fun aggregateVotes(request: QueryAggregateVotesRequest):
      QueryAggregateVotesResponse

  public suspend fun params(request: QueryParamsRequest): QueryParamsResponse
}