query.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: interchain_security/ccv/provider/v1/query.proto

package types

import (
	context "context"
	fmt "fmt"
	types "github.com/cosmos/interchain-security/v2/x/ccv/consumer/types"
	types1 "github.com/cosmos/interchain-security/v2/x/ccv/types"
	_ "github.com/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	_ "google.golang.org/protobuf/types/known/timestamppb"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
var _ = time.Kitchen

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type QueryConsumerGenesisRequest struct {
	ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
}

func (m *QueryConsumerGenesisRequest) Reset()         { *m = QueryConsumerGenesisRequest{} }
func (m *QueryConsumerGenesisRequest) String() string { return proto.CompactTextString(m) }
func (*QueryConsumerGenesisRequest) ProtoMessage()    {}
func (*QueryConsumerGenesisRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{0}
}
func (m *QueryConsumerGenesisRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryConsumerGenesisRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryConsumerGenesisRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryConsumerGenesisRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryConsumerGenesisRequest.Merge(m, src)
}
func (m *QueryConsumerGenesisRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryConsumerGenesisRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryConsumerGenesisRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryConsumerGenesisRequest proto.InternalMessageInfo

func (m *QueryConsumerGenesisRequest) GetChainId() string {
	if m != nil {
		return m.ChainId
	}
	return ""
}

type QueryConsumerGenesisResponse struct {
	GenesisState types.GenesisState `protobuf:"bytes,1,opt,name=genesis_state,json=genesisState,proto3" json:"genesis_state"`
}

func (m *QueryConsumerGenesisResponse) Reset()         { *m = QueryConsumerGenesisResponse{} }
func (m *QueryConsumerGenesisResponse) String() string { return proto.CompactTextString(m) }
func (*QueryConsumerGenesisResponse) ProtoMessage()    {}
func (*QueryConsumerGenesisResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{1}
}
func (m *QueryConsumerGenesisResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryConsumerGenesisResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryConsumerGenesisResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryConsumerGenesisResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryConsumerGenesisResponse.Merge(m, src)
}
func (m *QueryConsumerGenesisResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryConsumerGenesisResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryConsumerGenesisResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryConsumerGenesisResponse proto.InternalMessageInfo

func (m *QueryConsumerGenesisResponse) GetGenesisState() types.GenesisState {
	if m != nil {
		return m.GenesisState
	}
	return types.GenesisState{}
}

type QueryConsumerChainsRequest struct {
}

func (m *QueryConsumerChainsRequest) Reset()         { *m = QueryConsumerChainsRequest{} }
func (m *QueryConsumerChainsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryConsumerChainsRequest) ProtoMessage()    {}
func (*QueryConsumerChainsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{2}
}
func (m *QueryConsumerChainsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryConsumerChainsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryConsumerChainsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryConsumerChainsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryConsumerChainsRequest.Merge(m, src)
}
func (m *QueryConsumerChainsRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryConsumerChainsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryConsumerChainsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryConsumerChainsRequest proto.InternalMessageInfo

type QueryConsumerChainsResponse struct {
	Chains []*Chain `protobuf:"bytes,1,rep,name=chains,proto3" json:"chains,omitempty"`
}

func (m *QueryConsumerChainsResponse) Reset()         { *m = QueryConsumerChainsResponse{} }
func (m *QueryConsumerChainsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryConsumerChainsResponse) ProtoMessage()    {}
func (*QueryConsumerChainsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{3}
}
func (m *QueryConsumerChainsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryConsumerChainsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryConsumerChainsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryConsumerChainsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryConsumerChainsResponse.Merge(m, src)
}
func (m *QueryConsumerChainsResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryConsumerChainsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryConsumerChainsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryConsumerChainsResponse proto.InternalMessageInfo

func (m *QueryConsumerChainsResponse) GetChains() []*Chain {
	if m != nil {
		return m.Chains
	}
	return nil
}

type QueryConsumerChainStartProposalsRequest struct {
}

func (m *QueryConsumerChainStartProposalsRequest) Reset() {
	*m = QueryConsumerChainStartProposalsRequest{}
}
func (m *QueryConsumerChainStartProposalsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryConsumerChainStartProposalsRequest) ProtoMessage()    {}
func (*QueryConsumerChainStartProposalsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{4}
}
func (m *QueryConsumerChainStartProposalsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryConsumerChainStartProposalsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryConsumerChainStartProposalsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryConsumerChainStartProposalsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryConsumerChainStartProposalsRequest.Merge(m, src)
}
func (m *QueryConsumerChainStartProposalsRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryConsumerChainStartProposalsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryConsumerChainStartProposalsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryConsumerChainStartProposalsRequest proto.InternalMessageInfo

type QueryConsumerChainStartProposalsResponse struct {
	Proposals *ConsumerAdditionProposals `protobuf:"bytes,1,opt,name=proposals,proto3" json:"proposals,omitempty"`
}

func (m *QueryConsumerChainStartProposalsResponse) Reset() {
	*m = QueryConsumerChainStartProposalsResponse{}
}
func (m *QueryConsumerChainStartProposalsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryConsumerChainStartProposalsResponse) ProtoMessage()    {}
func (*QueryConsumerChainStartProposalsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{5}
}
func (m *QueryConsumerChainStartProposalsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryConsumerChainStartProposalsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryConsumerChainStartProposalsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryConsumerChainStartProposalsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryConsumerChainStartProposalsResponse.Merge(m, src)
}
func (m *QueryConsumerChainStartProposalsResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryConsumerChainStartProposalsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryConsumerChainStartProposalsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryConsumerChainStartProposalsResponse proto.InternalMessageInfo

func (m *QueryConsumerChainStartProposalsResponse) GetProposals() *ConsumerAdditionProposals {
	if m != nil {
		return m.Proposals
	}
	return nil
}

type QueryConsumerChainStopProposalsRequest struct {
}

func (m *QueryConsumerChainStopProposalsRequest) Reset() {
	*m = QueryConsumerChainStopProposalsRequest{}
}
func (m *QueryConsumerChainStopProposalsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryConsumerChainStopProposalsRequest) ProtoMessage()    {}
func (*QueryConsumerChainStopProposalsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{6}
}
func (m *QueryConsumerChainStopProposalsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryConsumerChainStopProposalsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryConsumerChainStopProposalsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryConsumerChainStopProposalsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryConsumerChainStopProposalsRequest.Merge(m, src)
}
func (m *QueryConsumerChainStopProposalsRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryConsumerChainStopProposalsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryConsumerChainStopProposalsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryConsumerChainStopProposalsRequest proto.InternalMessageInfo

type QueryConsumerChainStopProposalsResponse struct {
	Proposals *ConsumerRemovalProposals `protobuf:"bytes,1,opt,name=proposals,proto3" json:"proposals,omitempty"`
}

func (m *QueryConsumerChainStopProposalsResponse) Reset() {
	*m = QueryConsumerChainStopProposalsResponse{}
}
func (m *QueryConsumerChainStopProposalsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryConsumerChainStopProposalsResponse) ProtoMessage()    {}
func (*QueryConsumerChainStopProposalsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{7}
}
func (m *QueryConsumerChainStopProposalsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryConsumerChainStopProposalsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryConsumerChainStopProposalsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryConsumerChainStopProposalsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryConsumerChainStopProposalsResponse.Merge(m, src)
}
func (m *QueryConsumerChainStopProposalsResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryConsumerChainStopProposalsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryConsumerChainStopProposalsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryConsumerChainStopProposalsResponse proto.InternalMessageInfo

func (m *QueryConsumerChainStopProposalsResponse) GetProposals() *ConsumerRemovalProposals {
	if m != nil {
		return m.Proposals
	}
	return nil
}

type Chain struct {
	ChainId  string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	ClientId string `protobuf:"bytes,2,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
}

func (m *Chain) Reset()         { *m = Chain{} }
func (m *Chain) String() string { return proto.CompactTextString(m) }
func (*Chain) ProtoMessage()    {}
func (*Chain) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{8}
}
func (m *Chain) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Chain) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Chain.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Chain) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Chain.Merge(m, src)
}
func (m *Chain) XXX_Size() int {
	return m.Size()
}
func (m *Chain) XXX_DiscardUnknown() {
	xxx_messageInfo_Chain.DiscardUnknown(m)
}

var xxx_messageInfo_Chain proto.InternalMessageInfo

func (m *Chain) GetChainId() string {
	if m != nil {
		return m.ChainId
	}
	return ""
}

func (m *Chain) GetClientId() string {
	if m != nil {
		return m.ClientId
	}
	return ""
}

type QueryValidatorConsumerAddrRequest struct {
	// The id of the consumer chain
	ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	// The consensus address of the validator on the provider chain
	ProviderAddress string `protobuf:"bytes,2,opt,name=provider_address,json=providerAddress,proto3" json:"provider_address,omitempty" yaml:"address"`
}

func (m *QueryValidatorConsumerAddrRequest) Reset()         { *m = QueryValidatorConsumerAddrRequest{} }
func (m *QueryValidatorConsumerAddrRequest) String() string { return proto.CompactTextString(m) }
func (*QueryValidatorConsumerAddrRequest) ProtoMessage()    {}
func (*QueryValidatorConsumerAddrRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{9}
}
func (m *QueryValidatorConsumerAddrRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryValidatorConsumerAddrRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryValidatorConsumerAddrRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryValidatorConsumerAddrRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryValidatorConsumerAddrRequest.Merge(m, src)
}
func (m *QueryValidatorConsumerAddrRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryValidatorConsumerAddrRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryValidatorConsumerAddrRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryValidatorConsumerAddrRequest proto.InternalMessageInfo

type QueryValidatorConsumerAddrResponse struct {
	// The address of the validator on the consumer chain
	ConsumerAddress string `protobuf:"bytes,1,opt,name=consumer_address,json=consumerAddress,proto3" json:"consumer_address,omitempty"`
}

func (m *QueryValidatorConsumerAddrResponse) Reset()         { *m = QueryValidatorConsumerAddrResponse{} }
func (m *QueryValidatorConsumerAddrResponse) String() string { return proto.CompactTextString(m) }
func (*QueryValidatorConsumerAddrResponse) ProtoMessage()    {}
func (*QueryValidatorConsumerAddrResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{10}
}
func (m *QueryValidatorConsumerAddrResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryValidatorConsumerAddrResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryValidatorConsumerAddrResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryValidatorConsumerAddrResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryValidatorConsumerAddrResponse.Merge(m, src)
}
func (m *QueryValidatorConsumerAddrResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryValidatorConsumerAddrResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryValidatorConsumerAddrResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryValidatorConsumerAddrResponse proto.InternalMessageInfo

func (m *QueryValidatorConsumerAddrResponse) GetConsumerAddress() string {
	if m != nil {
		return m.ConsumerAddress
	}
	return ""
}

type QueryValidatorProviderAddrRequest struct {
	// The id of the provider chain
	ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	// The consensus address of the validator on the consumer chain
	ConsumerAddress string `protobuf:"bytes,2,opt,name=consumer_address,json=consumerAddress,proto3" json:"consumer_address,omitempty" yaml:"address"`
}

func (m *QueryValidatorProviderAddrRequest) Reset()         { *m = QueryValidatorProviderAddrRequest{} }
func (m *QueryValidatorProviderAddrRequest) String() string { return proto.CompactTextString(m) }
func (*QueryValidatorProviderAddrRequest) ProtoMessage()    {}
func (*QueryValidatorProviderAddrRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{11}
}
func (m *QueryValidatorProviderAddrRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryValidatorProviderAddrRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryValidatorProviderAddrRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryValidatorProviderAddrRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryValidatorProviderAddrRequest.Merge(m, src)
}
func (m *QueryValidatorProviderAddrRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryValidatorProviderAddrRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryValidatorProviderAddrRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryValidatorProviderAddrRequest proto.InternalMessageInfo

type QueryValidatorProviderAddrResponse struct {
	// The address of the validator on the provider chain
	ProviderAddress string `protobuf:"bytes,1,opt,name=provider_address,json=providerAddress,proto3" json:"provider_address,omitempty"`
}

func (m *QueryValidatorProviderAddrResponse) Reset()         { *m = QueryValidatorProviderAddrResponse{} }
func (m *QueryValidatorProviderAddrResponse) String() string { return proto.CompactTextString(m) }
func (*QueryValidatorProviderAddrResponse) ProtoMessage()    {}
func (*QueryValidatorProviderAddrResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{12}
}
func (m *QueryValidatorProviderAddrResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryValidatorProviderAddrResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryValidatorProviderAddrResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryValidatorProviderAddrResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryValidatorProviderAddrResponse.Merge(m, src)
}
func (m *QueryValidatorProviderAddrResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryValidatorProviderAddrResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryValidatorProviderAddrResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryValidatorProviderAddrResponse proto.InternalMessageInfo

func (m *QueryValidatorProviderAddrResponse) GetProviderAddress() string {
	if m != nil {
		return m.ProviderAddress
	}
	return ""
}

type QueryThrottleStateRequest struct {
}

func (m *QueryThrottleStateRequest) Reset()         { *m = QueryThrottleStateRequest{} }
func (m *QueryThrottleStateRequest) String() string { return proto.CompactTextString(m) }
func (*QueryThrottleStateRequest) ProtoMessage()    {}
func (*QueryThrottleStateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{13}
}
func (m *QueryThrottleStateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryThrottleStateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryThrottleStateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryThrottleStateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryThrottleStateRequest.Merge(m, src)
}
func (m *QueryThrottleStateRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryThrottleStateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryThrottleStateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryThrottleStateRequest proto.InternalMessageInfo

type QueryThrottleStateResponse struct {
	// current slash_meter state
	SlashMeter int64 `protobuf:"varint,1,opt,name=slash_meter,json=slashMeter,proto3" json:"slash_meter,omitempty"`
	// allowance of voting power units (int) that the slash meter is given per replenish period
	// this also serves as the max value for the meter.
	SlashMeterAllowance int64 `protobuf:"varint,2,opt,name=slash_meter_allowance,json=slashMeterAllowance,proto3" json:"slash_meter_allowance,omitempty"`
	// next time the slash meter could potentially be replenished, iff it's not full
	NextReplenishCandidate time.Time `protobuf:"bytes,3,opt,name=next_replenish_candidate,json=nextReplenishCandidate,proto3,stdtime" json:"next_replenish_candidate"`
	// data relevant to currently throttled slash packets
	Packets []*ThrottledSlashPacket `protobuf:"bytes,4,rep,name=packets,proto3" json:"packets,omitempty"`
}

func (m *QueryThrottleStateResponse) Reset()         { *m = QueryThrottleStateResponse{} }
func (m *QueryThrottleStateResponse) String() string { return proto.CompactTextString(m) }
func (*QueryThrottleStateResponse) ProtoMessage()    {}
func (*QueryThrottleStateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{14}
}
func (m *QueryThrottleStateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryThrottleStateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryThrottleStateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryThrottleStateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryThrottleStateResponse.Merge(m, src)
}
func (m *QueryThrottleStateResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryThrottleStateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryThrottleStateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryThrottleStateResponse proto.InternalMessageInfo

func (m *QueryThrottleStateResponse) GetSlashMeter() int64 {
	if m != nil {
		return m.SlashMeter
	}
	return 0
}

func (m *QueryThrottleStateResponse) GetSlashMeterAllowance() int64 {
	if m != nil {
		return m.SlashMeterAllowance
	}
	return 0
}

func (m *QueryThrottleStateResponse) GetNextReplenishCandidate() time.Time {
	if m != nil {
		return m.NextReplenishCandidate
	}
	return time.Time{}
}

func (m *QueryThrottleStateResponse) GetPackets() []*ThrottledSlashPacket {
	if m != nil {
		return m.Packets
	}
	return nil
}

type QueryThrottledConsumerPacketDataRequest struct {
	ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
}

func (m *QueryThrottledConsumerPacketDataRequest) Reset() {
	*m = QueryThrottledConsumerPacketDataRequest{}
}
func (m *QueryThrottledConsumerPacketDataRequest) String() string { return proto.CompactTextString(m) }
func (*QueryThrottledConsumerPacketDataRequest) ProtoMessage()    {}
func (*QueryThrottledConsumerPacketDataRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{15}
}
func (m *QueryThrottledConsumerPacketDataRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryThrottledConsumerPacketDataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryThrottledConsumerPacketDataRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryThrottledConsumerPacketDataRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryThrottledConsumerPacketDataRequest.Merge(m, src)
}
func (m *QueryThrottledConsumerPacketDataRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryThrottledConsumerPacketDataRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryThrottledConsumerPacketDataRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryThrottledConsumerPacketDataRequest proto.InternalMessageInfo

func (m *QueryThrottledConsumerPacketDataRequest) GetChainId() string {
	if m != nil {
		return m.ChainId
	}
	return ""
}

type QueryThrottledConsumerPacketDataResponse struct {
	ChainId             string                       `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	Size_               uint64                       `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	PacketDataInstances []ThrottledPacketDataWrapper `protobuf:"bytes,3,rep,name=packetDataInstances,proto3" json:"packetDataInstances"`
}

func (m *QueryThrottledConsumerPacketDataResponse) Reset() {
	*m = QueryThrottledConsumerPacketDataResponse{}
}
func (m *QueryThrottledConsumerPacketDataResponse) String() string { return proto.CompactTextString(m) }
func (*QueryThrottledConsumerPacketDataResponse) ProtoMessage()    {}
func (*QueryThrottledConsumerPacketDataResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{16}
}
func (m *QueryThrottledConsumerPacketDataResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryThrottledConsumerPacketDataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryThrottledConsumerPacketDataResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryThrottledConsumerPacketDataResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryThrottledConsumerPacketDataResponse.Merge(m, src)
}
func (m *QueryThrottledConsumerPacketDataResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryThrottledConsumerPacketDataResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryThrottledConsumerPacketDataResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryThrottledConsumerPacketDataResponse proto.InternalMessageInfo

func (m *QueryThrottledConsumerPacketDataResponse) GetChainId() string {
	if m != nil {
		return m.ChainId
	}
	return ""
}

func (m *QueryThrottledConsumerPacketDataResponse) GetSize_() uint64 {
	if m != nil {
		return m.Size_
	}
	return 0
}

func (m *QueryThrottledConsumerPacketDataResponse) GetPacketDataInstances() []ThrottledPacketDataWrapper {
	if m != nil {
		return m.PacketDataInstances
	}
	return nil
}

// A query wrapper type for the global entry and data relevant to a throttled slash packet.
type ThrottledSlashPacket struct {
	GlobalEntry GlobalSlashEntry       `protobuf:"bytes,1,opt,name=global_entry,json=globalEntry,proto3" json:"global_entry"`
	Data        types1.SlashPacketData `protobuf:"bytes,2,opt,name=data,proto3" json:"data"`
}

func (m *ThrottledSlashPacket) Reset()         { *m = ThrottledSlashPacket{} }
func (m *ThrottledSlashPacket) String() string { return proto.CompactTextString(m) }
func (*ThrottledSlashPacket) ProtoMessage()    {}
func (*ThrottledSlashPacket) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{17}
}
func (m *ThrottledSlashPacket) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ThrottledSlashPacket) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ThrottledSlashPacket.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ThrottledSlashPacket) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ThrottledSlashPacket.Merge(m, src)
}
func (m *ThrottledSlashPacket) XXX_Size() int {
	return m.Size()
}
func (m *ThrottledSlashPacket) XXX_DiscardUnknown() {
	xxx_messageInfo_ThrottledSlashPacket.DiscardUnknown(m)
}

var xxx_messageInfo_ThrottledSlashPacket proto.InternalMessageInfo

func (m *ThrottledSlashPacket) GetGlobalEntry() GlobalSlashEntry {
	if m != nil {
		return m.GlobalEntry
	}
	return GlobalSlashEntry{}
}

func (m *ThrottledSlashPacket) GetData() types1.SlashPacketData {
	if m != nil {
		return m.Data
	}
	return types1.SlashPacketData{}
}

// ThrottledPacketDataWrapper contains either SlashPacketData or VSCMaturedPacketData
type ThrottledPacketDataWrapper struct {
	// Types that are valid to be assigned to Data:
	//	*ThrottledPacketDataWrapper_SlashPacket
	//	*ThrottledPacketDataWrapper_VscMaturedPacket
	Data isThrottledPacketDataWrapper_Data `protobuf_oneof:"data"`
}

func (m *ThrottledPacketDataWrapper) Reset()         { *m = ThrottledPacketDataWrapper{} }
func (m *ThrottledPacketDataWrapper) String() string { return proto.CompactTextString(m) }
func (*ThrottledPacketDataWrapper) ProtoMessage()    {}
func (*ThrottledPacketDataWrapper) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{18}
}
func (m *ThrottledPacketDataWrapper) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ThrottledPacketDataWrapper) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ThrottledPacketDataWrapper.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ThrottledPacketDataWrapper) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ThrottledPacketDataWrapper.Merge(m, src)
}
func (m *ThrottledPacketDataWrapper) XXX_Size() int {
	return m.Size()
}
func (m *ThrottledPacketDataWrapper) XXX_DiscardUnknown() {
	xxx_messageInfo_ThrottledPacketDataWrapper.DiscardUnknown(m)
}

var xxx_messageInfo_ThrottledPacketDataWrapper proto.InternalMessageInfo

type isThrottledPacketDataWrapper_Data interface {
	isThrottledPacketDataWrapper_Data()
	MarshalTo([]byte) (int, error)
	Size() int
}

type ThrottledPacketDataWrapper_SlashPacket struct {
	SlashPacket *types1.SlashPacketData `protobuf:"bytes,1,opt,name=slash_packet,json=slashPacket,proto3,oneof" json:"slash_packet,omitempty"`
}
type ThrottledPacketDataWrapper_VscMaturedPacket struct {
	VscMaturedPacket *types1.VSCMaturedPacketData `protobuf:"bytes,2,opt,name=vsc_matured_packet,json=vscMaturedPacket,proto3,oneof" json:"vsc_matured_packet,omitempty"`
}

func (*ThrottledPacketDataWrapper_SlashPacket) isThrottledPacketDataWrapper_Data()      {}
func (*ThrottledPacketDataWrapper_VscMaturedPacket) isThrottledPacketDataWrapper_Data() {}

func (m *ThrottledPacketDataWrapper) GetData() isThrottledPacketDataWrapper_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *ThrottledPacketDataWrapper) GetSlashPacket() *types1.SlashPacketData {
	if x, ok := m.GetData().(*ThrottledPacketDataWrapper_SlashPacket); ok {
		return x.SlashPacket
	}
	return nil
}

func (m *ThrottledPacketDataWrapper) GetVscMaturedPacket() *types1.VSCMaturedPacketData {
	if x, ok := m.GetData().(*ThrottledPacketDataWrapper_VscMaturedPacket); ok {
		return x.VscMaturedPacket
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ThrottledPacketDataWrapper) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ThrottledPacketDataWrapper_SlashPacket)(nil),
		(*ThrottledPacketDataWrapper_VscMaturedPacket)(nil),
	}
}

type QueryRegisteredConsumerRewardDenomsRequest struct {
}

func (m *QueryRegisteredConsumerRewardDenomsRequest) Reset() {
	*m = QueryRegisteredConsumerRewardDenomsRequest{}
}
func (m *QueryRegisteredConsumerRewardDenomsRequest) String() string {
	return proto.CompactTextString(m)
}
func (*QueryRegisteredConsumerRewardDenomsRequest) ProtoMessage() {}
func (*QueryRegisteredConsumerRewardDenomsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{19}
}
func (m *QueryRegisteredConsumerRewardDenomsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryRegisteredConsumerRewardDenomsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryRegisteredConsumerRewardDenomsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryRegisteredConsumerRewardDenomsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryRegisteredConsumerRewardDenomsRequest.Merge(m, src)
}
func (m *QueryRegisteredConsumerRewardDenomsRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryRegisteredConsumerRewardDenomsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryRegisteredConsumerRewardDenomsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryRegisteredConsumerRewardDenomsRequest proto.InternalMessageInfo

type QueryRegisteredConsumerRewardDenomsResponse struct {
	Denoms []string `protobuf:"bytes,1,rep,name=denoms,proto3" json:"denoms,omitempty"`
}

func (m *QueryRegisteredConsumerRewardDenomsResponse) Reset() {
	*m = QueryRegisteredConsumerRewardDenomsResponse{}
}
func (m *QueryRegisteredConsumerRewardDenomsResponse) String() string {
	return proto.CompactTextString(m)
}
func (*QueryRegisteredConsumerRewardDenomsResponse) ProtoMessage() {}
func (*QueryRegisteredConsumerRewardDenomsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_422512d7b7586cd7, []int{20}
}
func (m *QueryRegisteredConsumerRewardDenomsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryRegisteredConsumerRewardDenomsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryRegisteredConsumerRewardDenomsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryRegisteredConsumerRewardDenomsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryRegisteredConsumerRewardDenomsResponse.Merge(m, src)
}
func (m *QueryRegisteredConsumerRewardDenomsResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryRegisteredConsumerRewardDenomsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryRegisteredConsumerRewardDenomsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryRegisteredConsumerRewardDenomsResponse proto.InternalMessageInfo

func (m *QueryRegisteredConsumerRewardDenomsResponse) GetDenoms() []string {
	if m != nil {
		return m.Denoms
	}
	return nil
}

func init() {
	proto.RegisterType((*QueryConsumerGenesisRequest)(nil), "interchain_security.ccv.provider.v1.QueryConsumerGenesisRequest")
	proto.RegisterType((*QueryConsumerGenesisResponse)(nil), "interchain_security.ccv.provider.v1.QueryConsumerGenesisResponse")
	proto.RegisterType((*QueryConsumerChainsRequest)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainsRequest")
	proto.RegisterType((*QueryConsumerChainsResponse)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainsResponse")
	proto.RegisterType((*QueryConsumerChainStartProposalsRequest)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainStartProposalsRequest")
	proto.RegisterType((*QueryConsumerChainStartProposalsResponse)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainStartProposalsResponse")
	proto.RegisterType((*QueryConsumerChainStopProposalsRequest)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainStopProposalsRequest")
	proto.RegisterType((*QueryConsumerChainStopProposalsResponse)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainStopProposalsResponse")
	proto.RegisterType((*Chain)(nil), "interchain_security.ccv.provider.v1.Chain")
	proto.RegisterType((*QueryValidatorConsumerAddrRequest)(nil), "interchain_security.ccv.provider.v1.QueryValidatorConsumerAddrRequest")
	proto.RegisterType((*QueryValidatorConsumerAddrResponse)(nil), "interchain_security.ccv.provider.v1.QueryValidatorConsumerAddrResponse")
	proto.RegisterType((*QueryValidatorProviderAddrRequest)(nil), "interchain_security.ccv.provider.v1.QueryValidatorProviderAddrRequest")
	proto.RegisterType((*QueryValidatorProviderAddrResponse)(nil), "interchain_security.ccv.provider.v1.QueryValidatorProviderAddrResponse")
	proto.RegisterType((*QueryThrottleStateRequest)(nil), "interchain_security.ccv.provider.v1.QueryThrottleStateRequest")
	proto.RegisterType((*QueryThrottleStateResponse)(nil), "interchain_security.ccv.provider.v1.QueryThrottleStateResponse")
	proto.RegisterType((*QueryThrottledConsumerPacketDataRequest)(nil), "interchain_security.ccv.provider.v1.QueryThrottledConsumerPacketDataRequest")
	proto.RegisterType((*QueryThrottledConsumerPacketDataResponse)(nil), "interchain_security.ccv.provider.v1.QueryThrottledConsumerPacketDataResponse")
	proto.RegisterType((*ThrottledSlashPacket)(nil), "interchain_security.ccv.provider.v1.ThrottledSlashPacket")
	proto.RegisterType((*ThrottledPacketDataWrapper)(nil), "interchain_security.ccv.provider.v1.ThrottledPacketDataWrapper")
	proto.RegisterType((*QueryRegisteredConsumerRewardDenomsRequest)(nil), "interchain_security.ccv.provider.v1.QueryRegisteredConsumerRewardDenomsRequest")
	proto.RegisterType((*QueryRegisteredConsumerRewardDenomsResponse)(nil), "interchain_security.ccv.provider.v1.QueryRegisteredConsumerRewardDenomsResponse")
}

func init() {
	proto.RegisterFile("interchain_security/ccv/provider/v1/query.proto", fileDescriptor_422512d7b7586cd7)
}

var fileDescriptor_422512d7b7586cd7 = []byte{
	// 1322 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xcf, 0x6f, 0xdc, 0x44,
	0x18, 0x5d, 0x6f, 0xd2, 0x34, 0x99, 0x14, 0x5a, 0xa6, 0xa5, 0x6c, 0xdd, 0x6a, 0xb7, 0xb8, 0x08,
	0xd2, 0x16, 0xec, 0xee, 0x56, 0x48, 0x4d, 0x20, 0xdd, 0xec, 0x26, 0x21, 0x8d, 0xda, 0xa8, 0xc1,
	0xa9, 0x5a, 0x09, 0x50, 0xcd, 0xc4, 0x1e, 0x36, 0x16, 0x5e, 0x8f, 0xeb, 0x99, 0x75, 0x1a, 0x7e,
	0x1c, 0x00, 0x09, 0x7a, 0xac, 0x84, 0xb8, 0x71, 0xe8, 0x89, 0xff, 0x82, 0x7b, 0x6f, 0x54, 0xf4,
	0xd2, 0x53, 0x41, 0x09, 0x07, 0x8e, 0x88, 0x3b, 0x12, 0xf2, 0x78, 0xbc, 0x3f, 0xb2, 0xde, 0x5d,
	0xef, 0x36, 0xb7, 0xdd, 0xf1, 0x7c, 0xef, 0x7b, 0xef, 0xe9, 0x9b, 0xf1, 0x33, 0xd0, 0x6c, 0x97,
	0x61, 0xdf, 0xdc, 0x42, 0xb6, 0x6b, 0x50, 0x6c, 0x36, 0x7c, 0x9b, 0xed, 0x68, 0xa6, 0x19, 0x68,
	0x9e, 0x4f, 0x02, 0xdb, 0xc2, 0xbe, 0x16, 0x14, 0xb5, 0x7b, 0x0d, 0xec, 0xef, 0xa8, 0x9e, 0x4f,
	0x18, 0x81, 0xe7, 0x12, 0x0a, 0x54, 0xd3, 0x0c, 0xd4, 0xb8, 0x40, 0x0d, 0x8a, 0xf2, 0x99, 0x1a,
	0x21, 0x35, 0x07, 0x6b, 0xc8, 0xb3, 0x35, 0xe4, 0xba, 0x84, 0x21, 0x66, 0x13, 0x97, 0x46, 0x10,
	0xf2, 0x89, 0x1a, 0xa9, 0x11, 0xfe, 0x53, 0x0b, 0x7f, 0x89, 0xd5, 0x82, 0xa8, 0xe1, 0xff, 0x36,
	0x1b, 0x9f, 0x69, 0xcc, 0xae, 0x63, 0xca, 0x50, 0xdd, 0x13, 0x1b, 0xde, 0xe8, 0x45, 0x35, 0x28,
	0x6a, 0x82, 0x00, 0x23, 0x72, 0xb1, 0xd7, 0x2e, 0x93, 0xb8, 0xb4, 0x51, 0x8f, 0x04, 0xd5, 0xb0,
	0x8b, 0xa9, 0x1d, 0xf3, 0x29, 0xa5, 0xf1, 0xa0, 0x29, 0x8f, 0xd7, 0x28, 0x57, 0xc0, 0xe9, 0x0f,
	0x43, 0x57, 0x16, 0x05, 0xea, 0x4a, 0x84, 0xa8, 0xe3, 0x7b, 0x0d, 0x4c, 0x19, 0x3c, 0x05, 0x26,
	0x23, 0x3c, 0xdb, 0xca, 0x49, 0x67, 0xa5, 0x99, 0x29, 0xfd, 0x30, 0xff, 0xbf, 0x6a, 0x29, 0x5f,
	0x81, 0x33, 0xc9, 0x95, 0xd4, 0x23, 0x2e, 0xc5, 0xf0, 0x13, 0xf0, 0x92, 0xa0, 0x67, 0x50, 0x86,
	0x18, 0xe6, 0xf5, 0xd3, 0xa5, 0xa2, 0xda, 0xcb, 0xf8, 0x58, 0x98, 0x1a, 0x14, 0x55, 0x01, 0xb6,
	0x11, 0x16, 0x56, 0xc7, 0x1f, 0x3f, 0x2f, 0x64, 0xf4, 0x23, 0xb5, 0xb6, 0x35, 0xe5, 0x0c, 0x90,
	0x3b, 0xba, 0x2f, 0x86, 0x78, 0x31, 0x6d, 0x05, 0xed, 0x53, 0x15, 0x3f, 0x15, 0xd4, 0xaa, 0x60,
	0x82, 0xf7, 0xa7, 0x39, 0xe9, 0xec, 0xd8, 0xcc, 0x74, 0xe9, 0x82, 0x9a, 0x62, 0x18, 0x54, 0x0e,
	0xa2, 0x8b, 0x4a, 0xe5, 0x3c, 0x78, 0xab, 0xbb, 0xc5, 0x06, 0x43, 0x3e, 0x5b, 0xf7, 0x89, 0x47,
	0x28, 0x72, 0x9a, 0x6c, 0x1e, 0x48, 0x60, 0x66, 0xf0, 0xde, 0xa6, 0x6d, 0x53, 0x5e, 0xbc, 0x28,
	0x2c, 0xbb, 0x9a, 0x8e, 0x9e, 0x00, 0xaf, 0x58, 0x96, 0x1d, 0x4e, 0x69, 0x0b, 0xba, 0x05, 0xa8,
	0xcc, 0x80, 0x37, 0x93, 0x98, 0x10, 0xaf, 0x8b, 0xf4, 0xf7, 0x52, 0xb2, 0xc0, 0x8e, 0xad, 0x82,
	0xf3, 0xc7, 0xdd, 0x9c, 0xe7, 0x87, 0xe2, 0xac, 0xe3, 0x3a, 0x09, 0x90, 0x93, 0x48, 0xb9, 0x0c,
	0x0e, 0xf1, 0xd6, 0x7d, 0x66, 0x11, 0x9e, 0x06, 0x53, 0xa6, 0x63, 0x63, 0x97, 0x85, 0xcf, 0xb2,
	0xfc, 0xd9, 0x64, 0xb4, 0xb0, 0x6a, 0x29, 0x3f, 0x48, 0xe0, 0x75, 0xae, 0xe4, 0x36, 0x72, 0x6c,
	0x0b, 0x31, 0xe2, 0xb7, 0x59, 0xe5, 0x0f, 0x9e, 0x74, 0x38, 0x0f, 0x8e, 0xc5, 0xa4, 0x0d, 0x64,
	0x59, 0x3e, 0xa6, 0x34, 0x6a, 0x52, 0x85, 0xff, 0x3e, 0x2f, 0xbc, 0xbc, 0x83, 0xea, 0xce, 0x9c,
	0x22, 0x1e, 0x28, 0xfa, 0xd1, 0x78, 0x6f, 0x25, 0x5a, 0x99, 0x9b, 0x7c, 0xf0, 0xa8, 0x90, 0xf9,
	0xfb, 0x51, 0x21, 0xa3, 0xdc, 0x04, 0x4a, 0x3f, 0x22, 0xc2, 0xcd, 0xf3, 0xe0, 0x58, 0x7c, 0x14,
	0x9a, 0xed, 0x22, 0x46, 0x47, 0xcd, 0xb6, 0xfd, 0x61, 0xb3, 0x6e, 0x69, 0xeb, 0x6d, 0xcd, 0xd3,
	0x49, 0xeb, 0xea, 0xd5, 0x47, 0xda, 0xbe, 0xfe, 0xfd, 0xa4, 0x75, 0x12, 0x69, 0x49, 0xeb, 0x72,
	0x52, 0x48, 0xdb, 0xe7, 0x9a, 0x72, 0x1a, 0x9c, 0xe2, 0x80, 0xb7, 0xb6, 0x7c, 0xc2, 0x98, 0x83,
	0xf9, 0xb1, 0x8f, 0x87, 0xf3, 0x97, 0xac, 0x38, 0xfe, 0xfb, 0x9e, 0x8a, 0x36, 0x05, 0x30, 0x4d,
	0x1d, 0x44, 0xb7, 0x8c, 0x3a, 0x66, 0xd8, 0xe7, 0x1d, 0xc6, 0x74, 0xc0, 0x97, 0xd6, 0xc2, 0x15,
	0x58, 0x02, 0xaf, 0xb6, 0x6d, 0x30, 0x90, 0xe3, 0x90, 0x6d, 0xe4, 0x9a, 0x98, 0x6b, 0x1f, 0xd3,
	0x8f, 0xb7, 0xb6, 0x56, 0xe2, 0x47, 0xf0, 0x2e, 0xc8, 0xb9, 0xf8, 0x3e, 0x33, 0x7c, 0xec, 0x39,
	0xd8, 0xb5, 0xe9, 0x96, 0x61, 0x22, 0xd7, 0x0a, 0xc5, 0xe2, 0xdc, 0x18, 0x9f, 0x79, 0x59, 0x8d,
	0xae, 0x7e, 0x35, 0xbe, 0xfa, 0xd5, 0x5b, 0xf1, 0xd5, 0x5f, 0x9d, 0x0c, 0xef, 0xb0, 0x87, 0x7f,
	0x14, 0x24, 0xfd, 0x64, 0x88, 0xa2, 0xc7, 0x20, 0x8b, 0x31, 0x06, 0xdc, 0x00, 0x87, 0x3d, 0x64,
	0x7e, 0x8e, 0x19, 0xcd, 0x8d, 0xf3, 0x5b, 0x69, 0x36, 0xd5, 0x11, 0x8a, 0x1d, 0xb0, 0x36, 0x42,
	0xce, 0xeb, 0x1c, 0x41, 0x8f, 0x91, 0x94, 0x25, 0x71, 0x88, 0x9b, 0xbb, 0xe2, 0x89, 0x8b, 0x36,
	0x2e, 0x21, 0x86, 0x52, 0x5c, 0xf5, 0xbf, 0xc7, 0x17, 0x58, 0x5f, 0x18, 0x61, 0x7e, 0x9f, 0x69,
	0x83, 0x60, 0x9c, 0xda, 0x5f, 0x44, 0x2e, 0x8f, 0xeb, 0xfc, 0x37, 0xdc, 0x06, 0xc7, 0xbd, 0x26,
	0xc8, 0xaa, 0x4b, 0x59, 0x68, 0x36, 0xcd, 0x8d, 0x71, 0x0b, 0xca, 0xc3, 0x59, 0xd0, 0x62, 0x73,
	0xc7, 0x47, 0x9e, 0x87, 0x7d, 0xf1, 0xea, 0x48, 0xea, 0xa0, 0xfc, 0x2a, 0x81, 0x13, 0x49, 0xe6,
	0xc1, 0xbb, 0xe0, 0x48, 0xcd, 0x21, 0x9b, 0xc8, 0x31, 0xb0, 0xcb, 0xfc, 0x1d, 0x71, 0xa1, 0xbd,
	0x9b, 0x8a, 0xca, 0x0a, 0x2f, 0xe4, 0x68, 0xcb, 0x61, 0xb1, 0x20, 0x30, 0x1d, 0x01, 0xf2, 0x25,
	0xb8, 0x0c, 0xc6, 0x2d, 0xc4, 0x10, 0x77, 0x61, 0xba, 0x74, 0xb1, 0x27, 0x6e, 0x50, 0x54, 0xdb,
	0x68, 0x85, 0xe4, 0x05, 0x1a, 0x2f, 0x57, 0x9e, 0x49, 0x40, 0xee, 0xad, 0x1c, 0xae, 0x83, 0x23,
	0xd1, 0x88, 0x47, 0xda, 0x85, 0x8a, 0x61, 0xba, 0x5d, 0xcb, 0xe8, 0xd1, 0x31, 0x12, 0xbe, 0x7c,
	0x0a, 0x60, 0x40, 0x4d, 0xa3, 0x8e, 0x58, 0xc3, 0xc7, 0x56, 0x8c, 0x1b, 0xa9, 0xb8, 0xd4, 0x0f,
	0xf7, 0xf6, 0xc6, 0xe2, 0x5a, 0x54, 0xd4, 0x01, 0x7e, 0x2c, 0xa0, 0x66, 0xc7, 0x7a, 0x75, 0x22,
	0x72, 0x46, 0x79, 0x1b, 0x5c, 0xe0, 0xe3, 0xa6, 0xe3, 0x9a, 0x4d, 0x19, 0xf6, 0x5b, 0xf3, 0xa6,
	0xe3, 0x6d, 0xe4, 0x5b, 0x4b, 0xd8, 0x25, 0xf5, 0xe6, 0x9b, 0x6a, 0x19, 0x5c, 0x4c, 0xb5, 0x5b,
	0xcc, 0xe7, 0x49, 0x30, 0x61, 0xf1, 0x15, 0xfe, 0xf2, 0x9f, 0xd2, 0xc5, 0xbf, 0xd2, 0xcf, 0xaf,
	0x80, 0x43, 0x1c, 0x07, 0xee, 0x4a, 0xe0, 0x44, 0x52, 0xb4, 0x81, 0x0b, 0xa9, 0x66, 0xa0, 0x4f,
	0x9e, 0x92, 0x2b, 0x2f, 0x80, 0x10, 0xf1, 0x57, 0x96, 0xbf, 0x7d, 0xfa, 0xd7, 0x8f, 0xd9, 0x32,
	0x9c, 0x1f, 0x1c, 0x79, 0x9b, 0x57, 0xbb, 0x88, 0x4e, 0xda, 0x97, 0xf1, 0xc9, 0xfc, 0x1a, 0x3e,
	0x95, 0xc0, 0xf1, 0x84, 0x8c, 0x04, 0xcb, 0xc3, 0x33, 0xec, 0xc8, 0x5e, 0xf2, 0xc2, 0xe8, 0x00,
	0x42, 0xe1, 0x2c, 0x57, 0x78, 0x19, 0x16, 0x87, 0x50, 0x18, 0xa5, 0x32, 0xf8, 0x4d, 0x16, 0xe4,
	0x7a, 0x44, 0x2d, 0x0a, 0x6f, 0x8c, 0xc8, 0x2c, 0x31, 0xd5, 0xc9, 0x6b, 0x07, 0x84, 0x26, 0x44,
	0x5f, 0xe3, 0xa2, 0xab, 0x70, 0x61, 0x58, 0xd1, 0x61, 0xba, 0xf6, 0x99, 0xd1, 0x0c, 0x4c, 0xf0,
	0x3f, 0x09, 0xbc, 0x96, 0x9c, 0xdc, 0x28, 0xbc, 0x3e, 0x32, 0xe9, 0xee, 0x88, 0x28, 0xdf, 0x38,
	0x18, 0x30, 0x61, 0xc0, 0x0a, 0x37, 0xa0, 0x02, 0xcb, 0x23, 0x18, 0x40, 0xbc, 0x36, 0xfd, 0xff,
	0x48, 0x22, 0x1c, 0x24, 0xc6, 0x2c, 0xf8, 0x41, 0x7a, 0xd6, 0xfd, 0x02, 0xa3, 0xbc, 0xf2, 0xc2,
	0x38, 0x42, 0x78, 0x85, 0x0b, 0x7f, 0x0f, 0xce, 0xa6, 0xf8, 0x86, 0x8d, 0x81, 0x8c, 0x8e, 0xd4,
	0x96, 0x20, 0xb9, 0x3d, 0x7e, 0x8d, 0x24, 0x39, 0x21, 0x48, 0x8e, 0x24, 0x39, 0x29, 0x07, 0x8e,
	0x26, 0xb9, 0x23, 0x39, 0xc2, 0xdf, 0x24, 0x00, 0xbb, 0x23, 0x20, 0xbc, 0x9a, 0x9e, 0x62, 0x52,
	0xb2, 0x94, 0xcb, 0x23, 0xd7, 0x0b, 0x69, 0x57, 0xb8, 0xb4, 0x12, 0xbc, 0x34, 0x58, 0x1a, 0x13,
	0x00, 0xd1, 0xf7, 0x31, 0xfc, 0x2e, 0x0b, 0xce, 0x0e, 0x4a, 0x59, 0xc3, 0xdc, 0x61, 0x83, 0x33,
	0xdf, 0x30, 0x77, 0x58, 0x8a, 0xe8, 0xa7, 0x54, 0xb9, 0xf6, 0xf7, 0xe1, 0xdc, 0x60, 0xed, 0x1e,
	0x76, 0x2d, 0xdb, 0xad, 0xb5, 0xe6, 0x58, 0x24, 0x56, 0xf8, 0x53, 0x16, 0x9c, 0x4b, 0xf1, 0x3a,
	0x87, 0x37, 0xd3, 0x53, 0x4f, 0x15, 0x23, 0xe4, 0xf5, 0x83, 0x03, 0x14, 0x76, 0x5c, 0xe7, 0x76,
	0x2c, 0xc3, 0xc5, 0xc1, 0x76, 0xf8, 0x4d, 0xc4, 0x96, 0x23, 0x3e, 0xc7, 0x34, 0xa2, 0x78, 0x52,
	0xbd, 0xf3, 0x78, 0x37, 0x2f, 0x3d, 0xd9, 0xcd, 0x4b, 0x7f, 0xee, 0xe6, 0xa5, 0x87, 0x7b, 0xf9,
	0xcc, 0x93, 0xbd, 0x7c, 0xe6, 0xd9, 0x5e, 0x3e, 0xf3, 0xd1, 0x7c, 0xcd, 0x66, 0x5b, 0x8d, 0x4d,
	0xd5, 0x24, 0x75, 0xcd, 0x24, 0xb4, 0x4e, 0x68, 0x5b, 0xbf, 0x77, 0x9a, 0xfd, 0x82, 0x92, 0x76,
	0x7f, 0xdf, 0xfc, 0xed, 0x78, 0x98, 0x6e, 0x4e, 0xf0, 0xaf, 0x95, 0xcb, 0xff, 0x07, 0x00, 0x00,
	0xff, 0xff, 0xb7, 0x37, 0x44, 0xeb, 0x42, 0x13, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// QueryClient is the client API for Query service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryClient interface {
	// ConsumerGenesis queries the genesis state needed to start a consumer chain
	// whose proposal has been accepted
	QueryConsumerGenesis(ctx context.Context, in *QueryConsumerGenesisRequest, opts ...grpc.CallOption) (*QueryConsumerGenesisResponse, error)
	// ConsumerChains queries active consumer chains supported by the provider
	// chain
	QueryConsumerChains(ctx context.Context, in *QueryConsumerChainsRequest, opts ...grpc.CallOption) (*QueryConsumerChainsResponse, error)
	// QueryConsumerChainStarts queries consumer chain start proposals.
	QueryConsumerChainStarts(ctx context.Context, in *QueryConsumerChainStartProposalsRequest, opts ...grpc.CallOption) (*QueryConsumerChainStartProposalsResponse, error)
	// QueryConsumerChainStops queries consumer chain stop proposals.
	QueryConsumerChainStops(ctx context.Context, in *QueryConsumerChainStopProposalsRequest, opts ...grpc.CallOption) (*QueryConsumerChainStopProposalsResponse, error)
	// QueryValidatorConsumerAddr queries the address
	// assigned by a validator for a consumer chain.
	QueryValidatorConsumerAddr(ctx context.Context, in *QueryValidatorConsumerAddrRequest, opts ...grpc.CallOption) (*QueryValidatorConsumerAddrResponse, error)
	// QueryProviderAddr returns the provider chain validator
	// given a consumer chain validator address
	QueryValidatorProviderAddr(ctx context.Context, in *QueryValidatorProviderAddrRequest, opts ...grpc.CallOption) (*QueryValidatorProviderAddrResponse, error)
	// QueryThrottleState returns the main on-chain state relevant to currently throttled slash packets
	QueryThrottleState(ctx context.Context, in *QueryThrottleStateRequest, opts ...grpc.CallOption) (*QueryThrottleStateResponse, error)
	// QueryThrottledConsumerPacketData returns a list of pending packet data instances
	// (slash packet and vsc matured) for a single consumer chain
	QueryThrottledConsumerPacketData(ctx context.Context, in *QueryThrottledConsumerPacketDataRequest, opts ...grpc.CallOption) (*QueryThrottledConsumerPacketDataResponse, error)
	// QueryRegisteredConsumerRewardDenoms returns a list of consumer reward denoms that are registered
	QueryRegisteredConsumerRewardDenoms(ctx context.Context, in *QueryRegisteredConsumerRewardDenomsRequest, opts ...grpc.CallOption) (*QueryRegisteredConsumerRewardDenomsResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

func NewQueryClient(cc grpc1.ClientConn) QueryClient {
	return &queryClient{cc}
}

func (c *queryClient) QueryConsumerGenesis(ctx context.Context, in *QueryConsumerGenesisRequest, opts ...grpc.CallOption) (*QueryConsumerGenesisResponse, error) {
	out := new(QueryConsumerGenesisResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryConsumerGenesis", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryConsumerChains(ctx context.Context, in *QueryConsumerChainsRequest, opts ...grpc.CallOption) (*QueryConsumerChainsResponse, error) {
	out := new(QueryConsumerChainsResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryConsumerChains", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryConsumerChainStarts(ctx context.Context, in *QueryConsumerChainStartProposalsRequest, opts ...grpc.CallOption) (*QueryConsumerChainStartProposalsResponse, error) {
	out := new(QueryConsumerChainStartProposalsResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryConsumerChainStarts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryConsumerChainStops(ctx context.Context, in *QueryConsumerChainStopProposalsRequest, opts ...grpc.CallOption) (*QueryConsumerChainStopProposalsResponse, error) {
	out := new(QueryConsumerChainStopProposalsResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryConsumerChainStops", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryValidatorConsumerAddr(ctx context.Context, in *QueryValidatorConsumerAddrRequest, opts ...grpc.CallOption) (*QueryValidatorConsumerAddrResponse, error) {
	out := new(QueryValidatorConsumerAddrResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryValidatorConsumerAddr", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryValidatorProviderAddr(ctx context.Context, in *QueryValidatorProviderAddrRequest, opts ...grpc.CallOption) (*QueryValidatorProviderAddrResponse, error) {
	out := new(QueryValidatorProviderAddrResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryValidatorProviderAddr", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryThrottleState(ctx context.Context, in *QueryThrottleStateRequest, opts ...grpc.CallOption) (*QueryThrottleStateResponse, error) {
	out := new(QueryThrottleStateResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryThrottleState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryThrottledConsumerPacketData(ctx context.Context, in *QueryThrottledConsumerPacketDataRequest, opts ...grpc.CallOption) (*QueryThrottledConsumerPacketDataResponse, error) {
	out := new(QueryThrottledConsumerPacketDataResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryThrottledConsumerPacketData", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryRegisteredConsumerRewardDenoms(ctx context.Context, in *QueryRegisteredConsumerRewardDenomsRequest, opts ...grpc.CallOption) (*QueryRegisteredConsumerRewardDenomsResponse, error) {
	out := new(QueryRegisteredConsumerRewardDenomsResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryRegisteredConsumerRewardDenoms", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// ConsumerGenesis queries the genesis state needed to start a consumer chain
	// whose proposal has been accepted
	QueryConsumerGenesis(context.Context, *QueryConsumerGenesisRequest) (*QueryConsumerGenesisResponse, error)
	// ConsumerChains queries active consumer chains supported by the provider
	// chain
	QueryConsumerChains(context.Context, *QueryConsumerChainsRequest) (*QueryConsumerChainsResponse, error)
	// QueryConsumerChainStarts queries consumer chain start proposals.
	QueryConsumerChainStarts(context.Context, *QueryConsumerChainStartProposalsRequest) (*QueryConsumerChainStartProposalsResponse, error)
	// QueryConsumerChainStops queries consumer chain stop proposals.
	QueryConsumerChainStops(context.Context, *QueryConsumerChainStopProposalsRequest) (*QueryConsumerChainStopProposalsResponse, error)
	// QueryValidatorConsumerAddr queries the address
	// assigned by a validator for a consumer chain.
	QueryValidatorConsumerAddr(context.Context, *QueryValidatorConsumerAddrRequest) (*QueryValidatorConsumerAddrResponse, error)
	// QueryProviderAddr returns the provider chain validator
	// given a consumer chain validator address
	QueryValidatorProviderAddr(context.Context, *QueryValidatorProviderAddrRequest) (*QueryValidatorProviderAddrResponse, error)
	// QueryThrottleState returns the main on-chain state relevant to currently throttled slash packets
	QueryThrottleState(context.Context, *QueryThrottleStateRequest) (*QueryThrottleStateResponse, error)
	// QueryThrottledConsumerPacketData returns a list of pending packet data instances
	// (slash packet and vsc matured) for a single consumer chain
	QueryThrottledConsumerPacketData(context.Context, *QueryThrottledConsumerPacketDataRequest) (*QueryThrottledConsumerPacketDataResponse, error)
	// QueryRegisteredConsumerRewardDenoms returns a list of consumer reward denoms that are registered
	QueryRegisteredConsumerRewardDenoms(context.Context, *QueryRegisteredConsumerRewardDenomsRequest) (*QueryRegisteredConsumerRewardDenomsResponse, error)
}

// UnimplementedQueryServer can be embedded to have forward compatible implementations.
type UnimplementedQueryServer struct {
}

func (*UnimplementedQueryServer) QueryConsumerGenesis(ctx context.Context, req *QueryConsumerGenesisRequest) (*QueryConsumerGenesisResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryConsumerGenesis not implemented")
}
func (*UnimplementedQueryServer) QueryConsumerChains(ctx context.Context, req *QueryConsumerChainsRequest) (*QueryConsumerChainsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryConsumerChains not implemented")
}
func (*UnimplementedQueryServer) QueryConsumerChainStarts(ctx context.Context, req *QueryConsumerChainStartProposalsRequest) (*QueryConsumerChainStartProposalsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryConsumerChainStarts not implemented")
}
func (*UnimplementedQueryServer) QueryConsumerChainStops(ctx context.Context, req *QueryConsumerChainStopProposalsRequest) (*QueryConsumerChainStopProposalsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryConsumerChainStops not implemented")
}
func (*UnimplementedQueryServer) QueryValidatorConsumerAddr(ctx context.Context, req *QueryValidatorConsumerAddrRequest) (*QueryValidatorConsumerAddrResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryValidatorConsumerAddr not implemented")
}
func (*UnimplementedQueryServer) QueryValidatorProviderAddr(ctx context.Context, req *QueryValidatorProviderAddrRequest) (*QueryValidatorProviderAddrResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryValidatorProviderAddr not implemented")
}
func (*UnimplementedQueryServer) QueryThrottleState(ctx context.Context, req *QueryThrottleStateRequest) (*QueryThrottleStateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryThrottleState not implemented")
}
func (*UnimplementedQueryServer) QueryThrottledConsumerPacketData(ctx context.Context, req *QueryThrottledConsumerPacketDataRequest) (*QueryThrottledConsumerPacketDataResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryThrottledConsumerPacketData not implemented")
}
func (*UnimplementedQueryServer) QueryRegisteredConsumerRewardDenoms(ctx context.Context, req *QueryRegisteredConsumerRewardDenomsRequest) (*QueryRegisteredConsumerRewardDenomsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryRegisteredConsumerRewardDenoms not implemented")
}

func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
	s.RegisterService(&_Query_serviceDesc, srv)
}

func _Query_QueryConsumerGenesis_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryConsumerGenesisRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryConsumerGenesis(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryConsumerGenesis",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryConsumerGenesis(ctx, req.(*QueryConsumerGenesisRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryConsumerChains_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryConsumerChainsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryConsumerChains(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryConsumerChains",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryConsumerChains(ctx, req.(*QueryConsumerChainsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryConsumerChainStarts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryConsumerChainStartProposalsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryConsumerChainStarts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryConsumerChainStarts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryConsumerChainStarts(ctx, req.(*QueryConsumerChainStartProposalsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryConsumerChainStops_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryConsumerChainStopProposalsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryConsumerChainStops(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryConsumerChainStops",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryConsumerChainStops(ctx, req.(*QueryConsumerChainStopProposalsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryValidatorConsumerAddr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryValidatorConsumerAddrRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryValidatorConsumerAddr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryValidatorConsumerAddr",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryValidatorConsumerAddr(ctx, req.(*QueryValidatorConsumerAddrRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryValidatorProviderAddr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryValidatorProviderAddrRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryValidatorProviderAddr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryValidatorProviderAddr",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryValidatorProviderAddr(ctx, req.(*QueryValidatorProviderAddrRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryThrottleState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryThrottleStateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryThrottleState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryThrottleState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryThrottleState(ctx, req.(*QueryThrottleStateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryThrottledConsumerPacketData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryThrottledConsumerPacketDataRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryThrottledConsumerPacketData(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryThrottledConsumerPacketData",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryThrottledConsumerPacketData(ctx, req.(*QueryThrottledConsumerPacketDataRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryRegisteredConsumerRewardDenoms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryRegisteredConsumerRewardDenomsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryRegisteredConsumerRewardDenoms(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryRegisteredConsumerRewardDenoms",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryRegisteredConsumerRewardDenoms(ctx, req.(*QueryRegisteredConsumerRewardDenomsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "interchain_security.ccv.provider.v1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "QueryConsumerGenesis",
			Handler:    _Query_QueryConsumerGenesis_Handler,
		},
		{
			MethodName: "QueryConsumerChains",
			Handler:    _Query_QueryConsumerChains_Handler,
		},
		{
			MethodName: "QueryConsumerChainStarts",
			Handler:    _Query_QueryConsumerChainStarts_Handler,
		},
		{
			MethodName: "QueryConsumerChainStops",
			Handler:    _Query_QueryConsumerChainStops_Handler,
		},
		{
			MethodName: "QueryValidatorConsumerAddr",
			Handler:    _Query_QueryValidatorConsumerAddr_Handler,
		},
		{
			MethodName: "QueryValidatorProviderAddr",
			Handler:    _Query_QueryValidatorProviderAddr_Handler,
		},
		{
			MethodName: "QueryThrottleState",
			Handler:    _Query_QueryThrottleState_Handler,
		},
		{
			MethodName: "QueryThrottledConsumerPacketData",
			Handler:    _Query_QueryThrottledConsumerPacketData_Handler,
		},
		{
			MethodName: "QueryRegisteredConsumerRewardDenoms",
			Handler:    _Query_QueryRegisteredConsumerRewardDenoms_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "interchain_security/ccv/provider/v1/query.proto",
}

func (m *QueryConsumerGenesisRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryConsumerGenesisRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryConsumerGenesisRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryConsumerGenesisResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryConsumerGenesisResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryConsumerGenesisResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.GenesisState.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *QueryConsumerChainsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryConsumerChainsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryConsumerChainsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *QueryConsumerChainsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryConsumerChainsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryConsumerChainsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Chains) > 0 {
		for iNdEx := len(m.Chains) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Chains[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *QueryConsumerChainStartProposalsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryConsumerChainStartProposalsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryConsumerChainStartProposalsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *QueryConsumerChainStartProposalsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryConsumerChainStartProposalsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryConsumerChainStartProposalsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Proposals != nil {
		{
			size, err := m.Proposals.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryConsumerChainStopProposalsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryConsumerChainStopProposalsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryConsumerChainStopProposalsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *QueryConsumerChainStopProposalsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryConsumerChainStopProposalsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryConsumerChainStopProposalsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Proposals != nil {
		{
			size, err := m.Proposals.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Chain) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Chain) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Chain) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ClientId) > 0 {
		i -= len(m.ClientId)
		copy(dAtA[i:], m.ClientId)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ClientId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryValidatorConsumerAddrRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryValidatorConsumerAddrRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryValidatorConsumerAddrRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ProviderAddress) > 0 {
		i -= len(m.ProviderAddress)
		copy(dAtA[i:], m.ProviderAddress)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ProviderAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryValidatorConsumerAddrResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryValidatorConsumerAddrResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryValidatorConsumerAddrResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ConsumerAddress) > 0 {
		i -= len(m.ConsumerAddress)
		copy(dAtA[i:], m.ConsumerAddress)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ConsumerAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryValidatorProviderAddrRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryValidatorProviderAddrRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryValidatorProviderAddrRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ConsumerAddress) > 0 {
		i -= len(m.ConsumerAddress)
		copy(dAtA[i:], m.ConsumerAddress)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ConsumerAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryValidatorProviderAddrResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryValidatorProviderAddrResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryValidatorProviderAddrResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ProviderAddress) > 0 {
		i -= len(m.ProviderAddress)
		copy(dAtA[i:], m.ProviderAddress)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ProviderAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryThrottleStateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryThrottleStateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryThrottleStateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *QueryThrottleStateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryThrottleStateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryThrottleStateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Packets) > 0 {
		for iNdEx := len(m.Packets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Packets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.NextReplenishCandidate, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.NextReplenishCandidate):])
	if err4 != nil {
		return 0, err4
	}
	i -= n4
	i = encodeVarintQuery(dAtA, i, uint64(n4))
	i--
	dAtA[i] = 0x1a
	if m.SlashMeterAllowance != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.SlashMeterAllowance))
		i--
		dAtA[i] = 0x10
	}
	if m.SlashMeter != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.SlashMeter))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *QueryThrottledConsumerPacketDataRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryThrottledConsumerPacketDataRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryThrottledConsumerPacketDataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryThrottledConsumerPacketDataResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryThrottledConsumerPacketDataResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryThrottledConsumerPacketDataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PacketDataInstances) > 0 {
		for iNdEx := len(m.PacketDataInstances) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PacketDataInstances[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Size_ != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Size_))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ThrottledSlashPacket) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ThrottledSlashPacket) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ThrottledSlashPacket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.GlobalEntry.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *ThrottledPacketDataWrapper) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ThrottledPacketDataWrapper) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ThrottledPacketDataWrapper) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Data != nil {
		{
			size := m.Data.Size()
			i -= size
			if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *ThrottledPacketDataWrapper_SlashPacket) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ThrottledPacketDataWrapper_SlashPacket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SlashPacket != nil {
		{
			size, err := m.SlashPacket.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *ThrottledPacketDataWrapper_VscMaturedPacket) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ThrottledPacketDataWrapper_VscMaturedPacket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.VscMaturedPacket != nil {
		{
			size, err := m.VscMaturedPacket.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *QueryRegisteredConsumerRewardDenomsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryRegisteredConsumerRewardDenomsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryRegisteredConsumerRewardDenomsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *QueryRegisteredConsumerRewardDenomsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryRegisteredConsumerRewardDenomsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryRegisteredConsumerRewardDenomsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Denoms) > 0 {
		for iNdEx := len(m.Denoms) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Denoms[iNdEx])
			copy(dAtA[i:], m.Denoms[iNdEx])
			i = encodeVarintQuery(dAtA, i, uint64(len(m.Denoms[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
	offset -= sovQuery(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *QueryConsumerGenesisRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryConsumerGenesisResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.GenesisState.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *QueryConsumerChainsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *QueryConsumerChainsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Chains) > 0 {
		for _, e := range m.Chains {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	return n
}

func (m *QueryConsumerChainStartProposalsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *QueryConsumerChainStartProposalsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Proposals != nil {
		l = m.Proposals.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryConsumerChainStopProposalsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *QueryConsumerChainStopProposalsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Proposals != nil {
		l = m.Proposals.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *Chain) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.ClientId)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryValidatorConsumerAddrRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.ProviderAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryValidatorConsumerAddrResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ConsumerAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryValidatorProviderAddrRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.ConsumerAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryValidatorProviderAddrResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProviderAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryThrottleStateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *QueryThrottleStateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SlashMeter != 0 {
		n += 1 + sovQuery(uint64(m.SlashMeter))
	}
	if m.SlashMeterAllowance != 0 {
		n += 1 + sovQuery(uint64(m.SlashMeterAllowance))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.NextReplenishCandidate)
	n += 1 + l + sovQuery(uint64(l))
	if len(m.Packets) > 0 {
		for _, e := range m.Packets {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	return n
}

func (m *QueryThrottledConsumerPacketDataRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryThrottledConsumerPacketDataResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Size_ != 0 {
		n += 1 + sovQuery(uint64(m.Size_))
	}
	if len(m.PacketDataInstances) > 0 {
		for _, e := range m.PacketDataInstances {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	return n
}

func (m *ThrottledSlashPacket) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.GlobalEntry.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.Data.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *ThrottledPacketDataWrapper) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Data != nil {
		n += m.Data.Size()
	}
	return n
}

func (m *ThrottledPacketDataWrapper_SlashPacket) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SlashPacket != nil {
		l = m.SlashPacket.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}
func (m *ThrottledPacketDataWrapper_VscMaturedPacket) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.VscMaturedPacket != nil {
		l = m.VscMaturedPacket.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}
func (m *QueryRegisteredConsumerRewardDenomsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *QueryRegisteredConsumerRewardDenomsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Denoms) > 0 {
		for _, s := range m.Denoms {
			l = len(s)
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	return n
}

func sovQuery(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozQuery(x uint64) (n int) {
	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *QueryConsumerGenesisRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryConsumerGenesisRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryConsumerGenesisRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryConsumerGenesisResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryConsumerGenesisResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryConsumerGenesisResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GenesisState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GenesisState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryConsumerChainsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryConsumerChainsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryConsumerChainsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryConsumerChainsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryConsumerChainsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryConsumerChainsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chains", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Chains = append(m.Chains, &Chain{})
			if err := m.Chains[len(m.Chains)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryConsumerChainStartProposalsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryConsumerChainStartProposalsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryConsumerChainStartProposalsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryConsumerChainStartProposalsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryConsumerChainStartProposalsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryConsumerChainStartProposalsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proposals", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Proposals == nil {
				m.Proposals = &ConsumerAdditionProposals{}
			}
			if err := m.Proposals.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryConsumerChainStopProposalsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryConsumerChainStopProposalsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryConsumerChainStopProposalsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryConsumerChainStopProposalsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryConsumerChainStopProposalsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryConsumerChainStopProposalsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proposals", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Proposals == nil {
				m.Proposals = &ConsumerRemovalProposals{}
			}
			if err := m.Proposals.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Chain) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Chain: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Chain: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClientId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryValidatorConsumerAddrRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryValidatorConsumerAddrRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryValidatorConsumerAddrRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProviderAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryValidatorConsumerAddrResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryValidatorConsumerAddrResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryValidatorConsumerAddrResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsumerAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConsumerAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryValidatorProviderAddrRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryValidatorProviderAddrRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryValidatorProviderAddrRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsumerAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConsumerAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryValidatorProviderAddrResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryValidatorProviderAddrResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryValidatorProviderAddrResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProviderAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryThrottleStateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryThrottleStateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryThrottleStateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryThrottleStateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryThrottleStateResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryThrottleStateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlashMeter", wireType)
			}
			m.SlashMeter = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SlashMeter |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlashMeterAllowance", wireType)
			}
			m.SlashMeterAllowance = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SlashMeterAllowance |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextReplenishCandidate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.NextReplenishCandidate, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Packets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Packets = append(m.Packets, &ThrottledSlashPacket{})
			if err := m.Packets[len(m.Packets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryThrottledConsumerPacketDataRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryThrottledConsumerPacketDataRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryThrottledConsumerPacketDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryThrottledConsumerPacketDataResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryThrottledConsumerPacketDataResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryThrottledConsumerPacketDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
			}
			m.Size_ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Size_ |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PacketDataInstances", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PacketDataInstances = append(m.PacketDataInstances, ThrottledPacketDataWrapper{})
			if err := m.PacketDataInstances[len(m.PacketDataInstances)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ThrottledSlashPacket) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ThrottledSlashPacket: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ThrottledSlashPacket: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalEntry", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GlobalEntry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ThrottledPacketDataWrapper) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ThrottledPacketDataWrapper: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ThrottledPacketDataWrapper: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlashPacket", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types1.SlashPacketData{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &ThrottledPacketDataWrapper_SlashPacket{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VscMaturedPacket", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types1.VSCMaturedPacketData{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &ThrottledPacketDataWrapper_VscMaturedPacket{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryRegisteredConsumerRewardDenomsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryRegisteredConsumerRewardDenomsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryRegisteredConsumerRewardDenomsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryRegisteredConsumerRewardDenomsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryRegisteredConsumerRewardDenomsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryRegisteredConsumerRewardDenomsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denoms", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Denoms = append(m.Denoms, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipQuery(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthQuery
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupQuery
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthQuery
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthQuery        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowQuery          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
)