query.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: nemo/committee/v1beta1/query.proto

package types

import (
	context "context"
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	types "github.com/cosmos/cosmos-sdk/codec/types"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	query "github.com/cosmos/cosmos-sdk/types/query"
	_ "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

// QueryCommitteesRequest defines the request type for querying x/committee committees.
type QueryCommitteesRequest struct {
}

func (m *QueryCommitteesRequest) Reset()         { *m = QueryCommitteesRequest{} }
func (m *QueryCommitteesRequest) String() string { return proto.CompactTextString(m) }
func (*QueryCommitteesRequest) ProtoMessage()    {}
func (*QueryCommitteesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{0}
}
func (m *QueryCommitteesRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryCommitteesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryCommitteesRequest.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 *QueryCommitteesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryCommitteesRequest.Merge(m, src)
}
func (m *QueryCommitteesRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryCommitteesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryCommitteesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryCommitteesRequest proto.InternalMessageInfo

// QueryCommitteesResponse defines the response type for querying x/committee committees.
type QueryCommitteesResponse struct {
	Committees []*types.Any `protobuf:"bytes,1,rep,name=committees,proto3" json:"committees,omitempty"`
}

func (m *QueryCommitteesResponse) Reset()         { *m = QueryCommitteesResponse{} }
func (m *QueryCommitteesResponse) String() string { return proto.CompactTextString(m) }
func (*QueryCommitteesResponse) ProtoMessage()    {}
func (*QueryCommitteesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{1}
}
func (m *QueryCommitteesResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryCommitteesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryCommitteesResponse.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 *QueryCommitteesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryCommitteesResponse.Merge(m, src)
}
func (m *QueryCommitteesResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryCommitteesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryCommitteesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryCommitteesResponse proto.InternalMessageInfo

// QueryCommitteeRequest defines the request type for querying x/committee committee.
type QueryCommitteeRequest struct {
	CommitteeId uint64 `protobuf:"varint,1,opt,name=committee_id,json=committeeId,proto3" json:"committee_id,omitempty"`
}

func (m *QueryCommitteeRequest) Reset()         { *m = QueryCommitteeRequest{} }
func (m *QueryCommitteeRequest) String() string { return proto.CompactTextString(m) }
func (*QueryCommitteeRequest) ProtoMessage()    {}
func (*QueryCommitteeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{2}
}
func (m *QueryCommitteeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryCommitteeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryCommitteeRequest.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 *QueryCommitteeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryCommitteeRequest.Merge(m, src)
}
func (m *QueryCommitteeRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryCommitteeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryCommitteeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryCommitteeRequest proto.InternalMessageInfo

// QueryCommitteeResponse defines the response type for querying x/committee committee.
type QueryCommitteeResponse struct {
	Committee *types.Any `protobuf:"bytes,1,opt,name=committee,proto3" json:"committee,omitempty"`
}

func (m *QueryCommitteeResponse) Reset()         { *m = QueryCommitteeResponse{} }
func (m *QueryCommitteeResponse) String() string { return proto.CompactTextString(m) }
func (*QueryCommitteeResponse) ProtoMessage()    {}
func (*QueryCommitteeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{3}
}
func (m *QueryCommitteeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryCommitteeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryCommitteeResponse.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 *QueryCommitteeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryCommitteeResponse.Merge(m, src)
}
func (m *QueryCommitteeResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryCommitteeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryCommitteeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryCommitteeResponse proto.InternalMessageInfo

// QueryProposalsRequest defines the request type for querying x/committee proposals.
type QueryProposalsRequest struct {
	CommitteeId uint64 `protobuf:"varint,1,opt,name=committee_id,json=committeeId,proto3" json:"committee_id,omitempty"`
}

func (m *QueryProposalsRequest) Reset()         { *m = QueryProposalsRequest{} }
func (m *QueryProposalsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryProposalsRequest) ProtoMessage()    {}
func (*QueryProposalsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{4}
}
func (m *QueryProposalsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryProposalsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryProposalsRequest.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 *QueryProposalsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryProposalsRequest.Merge(m, src)
}
func (m *QueryProposalsRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryProposalsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryProposalsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryProposalsRequest proto.InternalMessageInfo

// QueryProposalsResponse defines the response type for querying x/committee proposals.
type QueryProposalsResponse struct {
	Proposals []QueryProposalResponse `protobuf:"bytes,1,rep,name=proposals,proto3" json:"proposals"`
}

func (m *QueryProposalsResponse) Reset()         { *m = QueryProposalsResponse{} }
func (m *QueryProposalsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryProposalsResponse) ProtoMessage()    {}
func (*QueryProposalsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{5}
}
func (m *QueryProposalsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryProposalsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryProposalsResponse.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 *QueryProposalsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryProposalsResponse.Merge(m, src)
}
func (m *QueryProposalsResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryProposalsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryProposalsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryProposalsResponse proto.InternalMessageInfo

// QueryProposalRequest defines the request type for querying x/committee proposal.
type QueryProposalRequest struct {
	ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
}

func (m *QueryProposalRequest) Reset()         { *m = QueryProposalRequest{} }
func (m *QueryProposalRequest) String() string { return proto.CompactTextString(m) }
func (*QueryProposalRequest) ProtoMessage()    {}
func (*QueryProposalRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{6}
}
func (m *QueryProposalRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryProposalRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryProposalRequest.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 *QueryProposalRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryProposalRequest.Merge(m, src)
}
func (m *QueryProposalRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryProposalRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryProposalRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryProposalRequest proto.InternalMessageInfo

// QueryProposalResponse defines the response type for querying x/committee proposal.
type QueryProposalResponse struct {
	PubProposal *types.Any `protobuf:"bytes,1,opt,name=pub_proposal,json=pubProposal,proto3" json:"pub_proposal,omitempty"`
	ID          uint64     `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
	CommitteeID uint64     `protobuf:"varint,3,opt,name=committee_id,json=committeeId,proto3" json:"committee_id,omitempty"`
	Deadline    time.Time  `protobuf:"bytes,4,opt,name=deadline,proto3,stdtime" json:"deadline"`
}

func (m *QueryProposalResponse) Reset()         { *m = QueryProposalResponse{} }
func (m *QueryProposalResponse) String() string { return proto.CompactTextString(m) }
func (*QueryProposalResponse) ProtoMessage()    {}
func (*QueryProposalResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{7}
}
func (m *QueryProposalResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryProposalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryProposalResponse.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 *QueryProposalResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryProposalResponse.Merge(m, src)
}
func (m *QueryProposalResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryProposalResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryProposalResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryProposalResponse proto.InternalMessageInfo

// QueryNextProposalIDRequest defines the request type for querying x/committee NextProposalID.
type QueryNextProposalIDRequest struct {
}

func (m *QueryNextProposalIDRequest) Reset()         { *m = QueryNextProposalIDRequest{} }
func (m *QueryNextProposalIDRequest) String() string { return proto.CompactTextString(m) }
func (*QueryNextProposalIDRequest) ProtoMessage()    {}
func (*QueryNextProposalIDRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{8}
}
func (m *QueryNextProposalIDRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryNextProposalIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryNextProposalIDRequest.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 *QueryNextProposalIDRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryNextProposalIDRequest.Merge(m, src)
}
func (m *QueryNextProposalIDRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryNextProposalIDRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryNextProposalIDRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryNextProposalIDRequest proto.InternalMessageInfo

// QueryNextProposalIDRequest defines the response type for querying x/committee NextProposalID.
type QueryNextProposalIDResponse struct {
	NextProposalID uint64 `protobuf:"varint,1,opt,name=next_proposal_id,json=nextProposalId,proto3" json:"next_proposal_id,omitempty"`
}

func (m *QueryNextProposalIDResponse) Reset()         { *m = QueryNextProposalIDResponse{} }
func (m *QueryNextProposalIDResponse) String() string { return proto.CompactTextString(m) }
func (*QueryNextProposalIDResponse) ProtoMessage()    {}
func (*QueryNextProposalIDResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{9}
}
func (m *QueryNextProposalIDResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryNextProposalIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryNextProposalIDResponse.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 *QueryNextProposalIDResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryNextProposalIDResponse.Merge(m, src)
}
func (m *QueryNextProposalIDResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryNextProposalIDResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryNextProposalIDResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryNextProposalIDResponse proto.InternalMessageInfo

// QueryVotesRequest defines the request type for querying x/committee votes.
type QueryVotesRequest struct {
	ProposalId uint64             `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryVotesRequest) Reset()         { *m = QueryVotesRequest{} }
func (m *QueryVotesRequest) String() string { return proto.CompactTextString(m) }
func (*QueryVotesRequest) ProtoMessage()    {}
func (*QueryVotesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{10}
}
func (m *QueryVotesRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryVotesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryVotesRequest.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 *QueryVotesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryVotesRequest.Merge(m, src)
}
func (m *QueryVotesRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryVotesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryVotesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryVotesRequest proto.InternalMessageInfo

// QueryVotesResponse defines the response type for querying x/committee votes.
type QueryVotesResponse struct {
	// votes defined the queried votes.
	Votes []QueryVoteResponse `protobuf:"bytes,1,rep,name=votes,proto3" json:"votes"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryVotesResponse) Reset()         { *m = QueryVotesResponse{} }
func (m *QueryVotesResponse) String() string { return proto.CompactTextString(m) }
func (*QueryVotesResponse) ProtoMessage()    {}
func (*QueryVotesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{11}
}
func (m *QueryVotesResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryVotesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryVotesResponse.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 *QueryVotesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryVotesResponse.Merge(m, src)
}
func (m *QueryVotesResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryVotesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryVotesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryVotesResponse proto.InternalMessageInfo

// QueryVoteRequest defines the request type for querying x/committee vote.
type QueryVoteRequest struct {
	ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
	Voter      string `protobuf:"bytes,2,opt,name=voter,proto3" json:"voter,omitempty"`
}

func (m *QueryVoteRequest) Reset()         { *m = QueryVoteRequest{} }
func (m *QueryVoteRequest) String() string { return proto.CompactTextString(m) }
func (*QueryVoteRequest) ProtoMessage()    {}
func (*QueryVoteRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{12}
}
func (m *QueryVoteRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryVoteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryVoteRequest.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 *QueryVoteRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryVoteRequest.Merge(m, src)
}
func (m *QueryVoteRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryVoteRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryVoteRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryVoteRequest proto.InternalMessageInfo

// QueryVoteResponse defines the response type for querying x/committee vote.
type QueryVoteResponse struct {
	ProposalID uint64   `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
	Voter      string   `protobuf:"bytes,2,opt,name=voter,proto3" json:"voter,omitempty"`
	VoteType   VoteType `protobuf:"varint,3,opt,name=vote_type,json=voteType,proto3,enum=nemo.committee.v1beta1.VoteType" json:"vote_type,omitempty"`
}

func (m *QueryVoteResponse) Reset()         { *m = QueryVoteResponse{} }
func (m *QueryVoteResponse) String() string { return proto.CompactTextString(m) }
func (*QueryVoteResponse) ProtoMessage()    {}
func (*QueryVoteResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{13}
}
func (m *QueryVoteResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryVoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryVoteResponse.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 *QueryVoteResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryVoteResponse.Merge(m, src)
}
func (m *QueryVoteResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryVoteResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryVoteResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryVoteResponse proto.InternalMessageInfo

// QueryTallyRequest defines the request type for querying x/committee tally.
type QueryTallyRequest struct {
	ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
}

func (m *QueryTallyRequest) Reset()         { *m = QueryTallyRequest{} }
func (m *QueryTallyRequest) String() string { return proto.CompactTextString(m) }
func (*QueryTallyRequest) ProtoMessage()    {}
func (*QueryTallyRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{14}
}
func (m *QueryTallyRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryTallyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryTallyRequest.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 *QueryTallyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryTallyRequest.Merge(m, src)
}
func (m *QueryTallyRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryTallyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryTallyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryTallyRequest proto.InternalMessageInfo

// QueryTallyResponse defines the response type for querying x/committee tally.
type QueryTallyResponse struct {
	ProposalID    uint64                                 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
	YesVotes      github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=yes_votes,json=yesVotes,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"yes_votes"`
	NoVotes       github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=no_votes,json=noVotes,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"no_votes"`
	CurrentVotes  github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=current_votes,json=currentVotes,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"current_votes"`
	PossibleVotes github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,5,opt,name=possible_votes,json=possibleVotes,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"possible_votes"`
	VoteThreshold github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=vote_threshold,json=voteThreshold,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"vote_threshold"`
	Quorum        github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,7,opt,name=quorum,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"quorum"`
}

func (m *QueryTallyResponse) Reset()         { *m = QueryTallyResponse{} }
func (m *QueryTallyResponse) String() string { return proto.CompactTextString(m) }
func (*QueryTallyResponse) ProtoMessage()    {}
func (*QueryTallyResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{15}
}
func (m *QueryTallyResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryTallyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryTallyResponse.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 *QueryTallyResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryTallyResponse.Merge(m, src)
}
func (m *QueryTallyResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryTallyResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryTallyResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryTallyResponse proto.InternalMessageInfo

// QueryRawParamsRequest defines the request type for querying x/committee raw params.
type QueryRawParamsRequest struct {
	Subspace string `protobuf:"bytes,1,opt,name=subspace,proto3" json:"subspace,omitempty"`
	Key      string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
}

func (m *QueryRawParamsRequest) Reset()         { *m = QueryRawParamsRequest{} }
func (m *QueryRawParamsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryRawParamsRequest) ProtoMessage()    {}
func (*QueryRawParamsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{16}
}
func (m *QueryRawParamsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryRawParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryRawParamsRequest.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 *QueryRawParamsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryRawParamsRequest.Merge(m, src)
}
func (m *QueryRawParamsRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryRawParamsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryRawParamsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryRawParamsRequest proto.InternalMessageInfo

// QueryRawParamsResponse defines the response type for querying x/committee raw params.
type QueryRawParamsResponse struct {
	RawData string `protobuf:"bytes,1,opt,name=raw_data,json=rawData,proto3" json:"raw_data,omitempty"`
}

func (m *QueryRawParamsResponse) Reset()         { *m = QueryRawParamsResponse{} }
func (m *QueryRawParamsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryRawParamsResponse) ProtoMessage()    {}
func (*QueryRawParamsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e11a2758d73fcd1c, []int{17}
}
func (m *QueryRawParamsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryRawParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryRawParamsResponse.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 *QueryRawParamsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryRawParamsResponse.Merge(m, src)
}
func (m *QueryRawParamsResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryRawParamsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryRawParamsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryRawParamsResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*QueryCommitteesRequest)(nil), "nemo.committee.v1beta1.QueryCommitteesRequest")
	proto.RegisterType((*QueryCommitteesResponse)(nil), "nemo.committee.v1beta1.QueryCommitteesResponse")
	proto.RegisterType((*QueryCommitteeRequest)(nil), "nemo.committee.v1beta1.QueryCommitteeRequest")
	proto.RegisterType((*QueryCommitteeResponse)(nil), "nemo.committee.v1beta1.QueryCommitteeResponse")
	proto.RegisterType((*QueryProposalsRequest)(nil), "nemo.committee.v1beta1.QueryProposalsRequest")
	proto.RegisterType((*QueryProposalsResponse)(nil), "nemo.committee.v1beta1.QueryProposalsResponse")
	proto.RegisterType((*QueryProposalRequest)(nil), "nemo.committee.v1beta1.QueryProposalRequest")
	proto.RegisterType((*QueryProposalResponse)(nil), "nemo.committee.v1beta1.QueryProposalResponse")
	proto.RegisterType((*QueryNextProposalIDRequest)(nil), "nemo.committee.v1beta1.QueryNextProposalIDRequest")
	proto.RegisterType((*QueryNextProposalIDResponse)(nil), "nemo.committee.v1beta1.QueryNextProposalIDResponse")
	proto.RegisterType((*QueryVotesRequest)(nil), "nemo.committee.v1beta1.QueryVotesRequest")
	proto.RegisterType((*QueryVotesResponse)(nil), "nemo.committee.v1beta1.QueryVotesResponse")
	proto.RegisterType((*QueryVoteRequest)(nil), "nemo.committee.v1beta1.QueryVoteRequest")
	proto.RegisterType((*QueryVoteResponse)(nil), "nemo.committee.v1beta1.QueryVoteResponse")
	proto.RegisterType((*QueryTallyRequest)(nil), "nemo.committee.v1beta1.QueryTallyRequest")
	proto.RegisterType((*QueryTallyResponse)(nil), "nemo.committee.v1beta1.QueryTallyResponse")
	proto.RegisterType((*QueryRawParamsRequest)(nil), "nemo.committee.v1beta1.QueryRawParamsRequest")
	proto.RegisterType((*QueryRawParamsResponse)(nil), "nemo.committee.v1beta1.QueryRawParamsResponse")
}

func init() {
	proto.RegisterFile("nemo/committee/v1beta1/query.proto", fileDescriptor_e11a2758d73fcd1c)
}

var fileDescriptor_e11a2758d73fcd1c = []byte{
	// 1216 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x96, 0xc1, 0x6f, 0xe3, 0xc4,
	0x17, 0xc7, 0xeb, 0x34, 0x6d, 0x93, 0x49, 0xdb, 0x5f, 0x7f, 0xa3, 0x52, 0xd2, 0xb0, 0x4a, 0xba,
	0x66, 0xb5, 0x74, 0x2b, 0x62, 0xd3, 0x14, 0x54, 0x81, 0xa8, 0x60, 0xd3, 0x76, 0x51, 0x84, 0x04,
	0x5d, 0x53, 0x38, 0xb0, 0x12, 0xd1, 0x24, 0x9e, 0x4d, 0xad, 0x26, 0x1e, 0xd7, 0x63, 0xb7, 0x8d,
	0x4a, 0x2f, 0xdc, 0x91, 0x56, 0x42, 0x20, 0xed, 0x01, 0x09, 0x21, 0x90, 0x90, 0xb8, 0xa1, 0xfd,
	0x23, 0xaa, 0x3d, 0xad, 0xc4, 0x05, 0x71, 0x08, 0x90, 0xf2, 0x87, 0x20, 0xcf, 0x8c, 0x27, 0x6e,
	0xd2, 0x36, 0x6e, 0x4e, 0x89, 0xed, 0xf7, 0xbe, 0xf3, 0x99, 0x37, 0x6f, 0xde, 0x7b, 0x40, 0xb5,
	0x71, 0x8b, 0xe8, 0x75, 0xd2, 0x6a, 0x59, 0x9e, 0x87, 0xb1, 0x7e, 0xb8, 0x5a, 0xc3, 0x1e, 0x5a,
	0xd5, 0x0f, 0x7c, 0xec, 0xb6, 0x35, 0xc7, 0x25, 0x1e, 0x81, 0x0b, 0x81, 0x8d, 0x26, 0x6d, 0x34,
	0x61, 0x93, 0x5b, 0xa9, 0x13, 0xda, 0x22, 0x54, 0xaf, 0x21, 0x8a, 0xb9, 0x83, 0x74, 0x77, 0x50,
	0xc3, 0xb2, 0x91, 0x67, 0x11, 0x9b, 0x6b, 0xe4, 0x16, 0xb9, 0x6d, 0x95, 0x3d, 0xe9, 0xfc, 0x41,
	0x7c, 0x9a, 0x6f, 0x90, 0x06, 0xe1, 0xef, 0x83, 0x7f, 0xe2, 0xed, 0xad, 0x06, 0x21, 0x8d, 0x26,
	0xd6, 0x91, 0x63, 0xe9, 0xc8, 0xb6, 0x89, 0xc7, 0xd4, 0x42, 0x9f, 0x45, 0xf1, 0x95, 0x3d, 0xd5,
	0xfc, 0xc7, 0x3a, 0xb2, 0x05, 0x6d, 0xae, 0xd0, 0xff, 0xc9, 0xb3, 0x5a, 0x98, 0x7a, 0xa8, 0xe5,
	0x08, 0x83, 0x3b, 0x57, 0x6c, 0xb9, 0x81, 0x6d, 0x4c, 0x2d, 0xb1, 0x82, 0x9a, 0x05, 0x0b, 0x0f,
	0x83, 0x2d, 0x6d, 0x86, 0x76, 0xd4, 0xc0, 0x07, 0x3e, 0xa6, 0x9e, 0xfa, 0x05, 0x78, 0x79, 0xe0,
	0x0b, 0x75, 0x88, 0x4d, 0x31, 0xdc, 0x04, 0x40, 0xea, 0xd2, 0xac, 0xb2, 0x34, 0xbe, 0x9c, 0x29,
	0xcd, 0x6b, 0x1c, 0x48, 0x0b, 0x81, 0xb4, 0xfb, 0x76, 0xbb, 0x3c, 0xf3, 0xfc, 0x59, 0x31, 0x2d,
	0x15, 0x8c, 0x88, 0x9b, 0xfa, 0x0e, 0x78, 0xe9, 0xa2, 0xbe, 0x58, 0x18, 0xde, 0x06, 0xd3, 0xd2,
	0xac, 0x6a, 0x99, 0x59, 0x65, 0x49, 0x59, 0x4e, 0x1a, 0x19, 0xf9, 0xae, 0x62, 0xaa, 0x8f, 0xfa,
	0xa9, 0x25, 0xda, 0x7d, 0x90, 0x96, 0x86, 0xcc, 0x33, 0x26, 0x59, 0xcf, 0x4b, 0x82, 0xed, 0xb8,
	0xc4, 0x21, 0x14, 0x35, 0xe9, 0x0d, 0xc0, 0xf6, 0x05, 0x58, 0xc4, 0x57, 0x80, 0x3d, 0x04, 0x69,
	0x27, 0x7c, 0x29, 0x42, 0x56, 0xd4, 0x2e, 0xcf, 0x38, 0xed, 0x82, 0x44, 0xa8, 0x50, 0x4e, 0x9e,
	0x75, 0x0a, 0x63, 0x46, 0x4f, 0x45, 0x5d, 0x07, 0xf3, 0x7d, 0x96, 0x9c, 0xb3, 0x00, 0x32, 0xa1,
	0x51, 0x0f, 0x13, 0x84, 0xaf, 0x2a, 0xa6, 0xfa, 0x75, 0xa2, 0x6f, 0x8b, 0x92, 0xf2, 0x31, 0x98,
	0x76, 0xfc, 0x5a, 0x35, 0xb4, 0xbd, 0x36, 0x82, 0xc5, 0x6e, 0xa7, 0x90, 0xd9, 0xf1, 0x6b, 0xa1,
	0xc8, 0xf3, 0x67, 0xc5, 0x9c, 0xc8, 0xf8, 0x06, 0x39, 0x94, 0x9b, 0xd9, 0x24, 0xb6, 0x87, 0x6d,
	0xcf, 0xc8, 0x38, 0x3d, 0x53, 0xb8, 0x00, 0x12, 0x96, 0x99, 0x4d, 0x04, 0x64, 0xe5, 0xc9, 0x6e,
	0xa7, 0x90, 0xa8, 0x6c, 0x19, 0x09, 0xcb, 0x84, 0xa5, 0xbe, 0x10, 0x8f, 0x33, 0x8b, 0xff, 0x05,
	0x2b, 0xc9, 0xb3, 0xaa, 0x6c, 0x5d, 0x88, 0x39, 0x7c, 0x1f, 0xa4, 0x4c, 0x8c, 0xcc, 0xa6, 0x65,
	0xe3, 0x6c, 0x92, 0xf1, 0xe6, 0x06, 0x78, 0x77, 0xc3, 0xcb, 0x51, 0x4e, 0x05, 0x51, 0x7c, 0xf2,
	0x57, 0x41, 0x31, 0xa4, 0x97, 0x7a, 0x0b, 0xe4, 0x58, 0x38, 0x3e, 0xc2, 0xc7, 0x5e, 0x88, 0x58,
	0xd9, 0x0a, 0x2f, 0xc2, 0x23, 0xf0, 0xca, 0xa5, 0x5f, 0x45, 0xc8, 0xde, 0x05, 0x73, 0x36, 0x3e,
	0xf6, 0xaa, 0x03, 0x21, 0x2f, 0xc3, 0x6e, 0xa7, 0x30, 0xdb, 0xe7, 0x35, 0x6b, 0x47, 0x9f, 0x4d,
	0xf5, 0x4b, 0xf0, 0x7f, 0x26, 0xfe, 0x19, 0xf1, 0xe4, 0xd5, 0x1b, 0x7a, 0x80, 0xf0, 0x01, 0x00,
	0xbd, 0xd2, 0xc3, 0xc2, 0x98, 0x29, 0xdd, 0xd5, 0x44, 0xf0, 0x83, 0x3a, 0xa5, 0xf1, 0xc2, 0x16,
	0x9e, 0xc1, 0x0e, 0x6a, 0x84, 0xd7, 0xcb, 0x88, 0x78, 0xaa, 0x3f, 0x29, 0x00, 0x46, 0x97, 0x17,
	0x5b, 0xda, 0x06, 0x13, 0x87, 0xc1, 0x0b, 0x91, 0xa7, 0xf7, 0xae, 0xcd, 0xd3, 0xc0, 0xb5, 0x2f,
	0x47, 0xb9, 0x37, 0xfc, 0xe0, 0x12, 0xca, 0xd7, 0x86, 0x52, 0x72, 0xa5, 0x0b, 0x98, 0x15, 0x30,
	0x17, 0x59, 0x2a, 0x66, 0x8c, 0xe6, 0xf9, 0x26, 0x5c, 0xb6, 0x70, 0x9a, 0x33, 0xb9, 0xea, 0x53,
	0x25, 0x12, 0x70, 0xb9, 0x61, 0xfd, 0x12, 0xb1, 0xf2, 0x6c, 0xb7, 0x53, 0x00, 0x91, 0xa3, 0x1b,
	0x2a, 0x0e, 0x37, 0x40, 0x3a, 0xf8, 0x53, 0xf5, 0xda, 0x0e, 0x66, 0xa9, 0x3b, 0x5b, 0x5a, 0xba,
	0x2a, 0x76, 0xc1, 0xfa, 0xbb, 0x6d, 0x07, 0x1b, 0xa9, 0x43, 0xf1, 0x4f, 0x7d, 0x53, 0xa0, 0xed,
	0xa2, 0x66, 0xb3, 0x1d, 0xfb, 0x32, 0xff, 0x92, 0x14, 0x67, 0x28, 0xdc, 0x46, 0xdd, 0xd2, 0x87,
	0x20, 0xdd, 0xc6, 0xb4, 0xca, 0x0f, 0x9e, 0x6d, 0xab, 0xac, 0x05, 0xa7, 0xf9, 0x67, 0xa7, 0x70,
	0xb7, 0x61, 0x79, 0x7b, 0x7e, 0x2d, 0xd8, 0x85, 0xe8, 0x69, 0xe2, 0xa7, 0x48, 0xcd, 0x7d, 0x3d,
	0xd8, 0x2d, 0xd5, 0xb6, 0x70, 0xdd, 0x48, 0xb5, 0x31, 0x65, 0x99, 0x04, 0x2b, 0x20, 0x65, 0x13,
	0xa1, 0x35, 0x3e, 0x92, 0xd6, 0x94, 0x4d, 0xb8, 0xd4, 0x27, 0x60, 0xa6, 0xee, 0xbb, 0x2e, 0xb6,
	0x3d, 0xa1, 0x97, 0x1c, 0x49, 0x6f, 0x5a, 0x88, 0x70, 0xd1, 0x4f, 0xc1, 0xac, 0x43, 0x28, 0xb5,
	0x6a, 0x4d, 0x2c, 0x54, 0x27, 0x46, 0x52, 0x9d, 0x09, 0x55, 0xa4, 0x2c, 0x4f, 0x80, 0x3d, 0x17,
	0xd3, 0x3d, 0xd2, 0x34, 0xb3, 0x93, 0xa3, 0xc9, 0xb2, 0x9c, 0x08, 0x45, 0xe0, 0x03, 0x30, 0x79,
	0xe0, 0x13, 0xd7, 0x6f, 0x65, 0xa7, 0x46, 0x92, 0x13, 0xde, 0xea, 0xb6, 0x28, 0xfb, 0x06, 0x3a,
	0xda, 0x41, 0x2e, 0x6a, 0xc9, 0x82, 0x93, 0x03, 0x29, 0xea, 0xd7, 0xa8, 0x83, 0xea, 0xbc, 0x69,
	0xa6, 0x0d, 0xf9, 0x0c, 0xe7, 0xc0, 0xf8, 0x3e, 0x6e, 0x8b, 0x44, 0x0f, 0xfe, 0xaa, 0x6b, 0xa2,
	0xc9, 0x45, 0x64, 0x44, 0xd2, 0x2d, 0x82, 0x94, 0x8b, 0x8e, 0xaa, 0x26, 0xf2, 0x90, 0xd0, 0x99,
	0x72, 0xd1, 0xd1, 0x16, 0xf2, 0x50, 0xe9, 0xb7, 0x0c, 0x98, 0x60, 0x5e, 0xf0, 0xa9, 0x02, 0x40,
	0x6f, 0xa8, 0x80, 0xda, 0xb5, 0xd5, 0x65, 0x60, 0x2e, 0xc9, 0xe9, 0xb1, 0xed, 0x39, 0x94, 0xba,
	0xf2, 0xd5, 0xef, 0xff, 0x7e, 0x93, 0xb8, 0x03, 0x55, 0xfd, 0x8a, 0x89, 0xa8, 0x37, 0x94, 0xc0,
	0x9f, 0x15, 0xd0, 0x1b, 0x0a, 0x60, 0x31, 0xde, 0x52, 0x21, 0x99, 0x16, 0xd7, 0x5c, 0x80, 0xbd,
	0xcd, 0xc0, 0xd6, 0xe0, 0xea, 0x70, 0x30, 0xfd, 0x24, 0xda, 0x16, 0x4f, 0xe1, 0xb7, 0x0a, 0x48,
	0xcb, 0x19, 0x03, 0xc6, 0x1b, 0x24, 0x68, 0x3c, 0xce, 0x81, 0xd1, 0x45, 0xbd, 0xc7, 0x38, 0x5f,
	0x85, 0xb7, 0xaf, 0xe2, 0x94, 0x23, 0x09, 0xfc, 0x41, 0x01, 0x29, 0xd9, 0xe4, 0x5f, 0x8f, 0x39,
	0xdf, 0x70, 0xaa, 0x9b, 0x4d, 0x43, 0xea, 0x3a, 0x83, 0x5a, 0x85, 0xfa, 0x50, 0x28, 0xfd, 0x24,
	0x52, 0x08, 0x4f, 0xe1, 0xaf, 0x0a, 0xe8, 0x6b, 0xca, 0xb0, 0x74, 0xed, 0xd2, 0x97, 0x4e, 0x05,
	0xb9, 0xb5, 0x1b, 0xf9, 0x08, 0xe8, 0x37, 0x18, 0xf4, 0x0a, 0x5c, 0xbe, 0x0a, 0x3a, 0x98, 0x0e,
	0x8a, 0x21, 0x6e, 0xd1, 0x32, 0xe1, 0xf7, 0x0a, 0x98, 0xe0, 0xb5, 0x65, 0x78, 0x17, 0x96, 0x07,
	0xbc, 0x12, 0xc7, 0x54, 0x20, 0x6d, 0x30, 0xa4, 0x75, 0xf8, 0xd6, 0x0d, 0xe3, 0xa8, 0xf3, 0x1e,
	0xff, 0xa3, 0x02, 0x92, 0x81, 0x20, 0x5c, 0x8e, 0x31, 0x24, 0x70, 0xba, 0xf8, 0xe3, 0x84, 0xba,
	0xcd, 0xe0, 0xde, 0x83, 0x1b, 0x23, 0xc1, 0xe9, 0x27, 0xac, 0x2d, 0x9f, 0xb2, 0x20, 0xb2, 0xee,
	0x38, 0x24, 0x88, 0xd1, 0xc6, 0x3b, 0x24, 0x88, 0x17, 0x9a, 0xed, 0xe8, 0x41, 0xf4, 0x18, 0xd5,
	0x77, 0x0a, 0x48, 0xcb, 0x62, 0x3a, 0xe4, 0x36, 0xf7, 0xd7, 0xee, 0x21, 0xb7, 0x79, 0xa0, 0x46,
	0x0f, 0x2f, 0x87, 0x2e, 0x3a, 0x2a, 0x3a, 0xcc, 0xa7, 0xfc, 0xf1, 0xd9, 0x3f, 0xf9, 0xb1, 0xb3,
	0x6e, 0x5e, 0x79, 0xd1, 0xcd, 0x2b, 0x7f, 0x77, 0xf3, 0xca, 0x93, 0xf3, 0xfc, 0xd8, 0x8b, 0xf3,
	0xfc, 0xd8, 0x1f, 0xe7, 0xf9, 0xb1, 0xcf, 0x57, 0x23, 0xed, 0xc7, 0xb2, 0xeb, 0x7e, 0xcd, 0xa7,
	0x45, 0x1b, 0x7b, 0x47, 0xc4, 0xdd, 0xe7, 0xda, 0xc7, 0x11, 0x75, 0xd6, 0x8d, 0x6a, 0x93, 0x6c,
	0x22, 0x5f, 0xfb, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x3a, 0xf5, 0x60, 0x29, 0x90, 0x0f, 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 {
	// Committees queries all committess of the committee module.
	Committees(ctx context.Context, in *QueryCommitteesRequest, opts ...grpc.CallOption) (*QueryCommitteesResponse, error)
	// Committee queries a committee based on committee ID.
	Committee(ctx context.Context, in *QueryCommitteeRequest, opts ...grpc.CallOption) (*QueryCommitteeResponse, error)
	// Proposals queries proposals based on committee ID.
	Proposals(ctx context.Context, in *QueryProposalsRequest, opts ...grpc.CallOption) (*QueryProposalsResponse, error)
	// Deposits queries a proposal based on proposal ID.
	Proposal(ctx context.Context, in *QueryProposalRequest, opts ...grpc.CallOption) (*QueryProposalResponse, error)
	// NextProposalID queries the next proposal ID of the committee module.
	NextProposalID(ctx context.Context, in *QueryNextProposalIDRequest, opts ...grpc.CallOption) (*QueryNextProposalIDResponse, error)
	// Votes queries all votes for a single proposal ID.
	Votes(ctx context.Context, in *QueryVotesRequest, opts ...grpc.CallOption) (*QueryVotesResponse, error)
	// Vote queries the vote of a single voter for a single proposal ID.
	Vote(ctx context.Context, in *QueryVoteRequest, opts ...grpc.CallOption) (*QueryVoteResponse, error)
	// Tally queries the tally of a single proposal ID.
	Tally(ctx context.Context, in *QueryTallyRequest, opts ...grpc.CallOption) (*QueryTallyResponse, error)
	// RawParams queries the raw params data of any subspace and key.
	RawParams(ctx context.Context, in *QueryRawParamsRequest, opts ...grpc.CallOption) (*QueryRawParamsResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

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

func (c *queryClient) Committees(ctx context.Context, in *QueryCommitteesRequest, opts ...grpc.CallOption) (*QueryCommitteesResponse, error) {
	out := new(QueryCommitteesResponse)
	err := c.cc.Invoke(ctx, "/nemo.committee.v1beta1.Query/Committees", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Committee(ctx context.Context, in *QueryCommitteeRequest, opts ...grpc.CallOption) (*QueryCommitteeResponse, error) {
	out := new(QueryCommitteeResponse)
	err := c.cc.Invoke(ctx, "/nemo.committee.v1beta1.Query/Committee", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Proposals(ctx context.Context, in *QueryProposalsRequest, opts ...grpc.CallOption) (*QueryProposalsResponse, error) {
	out := new(QueryProposalsResponse)
	err := c.cc.Invoke(ctx, "/nemo.committee.v1beta1.Query/Proposals", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Proposal(ctx context.Context, in *QueryProposalRequest, opts ...grpc.CallOption) (*QueryProposalResponse, error) {
	out := new(QueryProposalResponse)
	err := c.cc.Invoke(ctx, "/nemo.committee.v1beta1.Query/Proposal", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) NextProposalID(ctx context.Context, in *QueryNextProposalIDRequest, opts ...grpc.CallOption) (*QueryNextProposalIDResponse, error) {
	out := new(QueryNextProposalIDResponse)
	err := c.cc.Invoke(ctx, "/nemo.committee.v1beta1.Query/NextProposalID", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Votes(ctx context.Context, in *QueryVotesRequest, opts ...grpc.CallOption) (*QueryVotesResponse, error) {
	out := new(QueryVotesResponse)
	err := c.cc.Invoke(ctx, "/nemo.committee.v1beta1.Query/Votes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Vote(ctx context.Context, in *QueryVoteRequest, opts ...grpc.CallOption) (*QueryVoteResponse, error) {
	out := new(QueryVoteResponse)
	err := c.cc.Invoke(ctx, "/nemo.committee.v1beta1.Query/Vote", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Tally(ctx context.Context, in *QueryTallyRequest, opts ...grpc.CallOption) (*QueryTallyResponse, error) {
	out := new(QueryTallyResponse)
	err := c.cc.Invoke(ctx, "/nemo.committee.v1beta1.Query/Tally", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) RawParams(ctx context.Context, in *QueryRawParamsRequest, opts ...grpc.CallOption) (*QueryRawParamsResponse, error) {
	out := new(QueryRawParamsResponse)
	err := c.cc.Invoke(ctx, "/nemo.committee.v1beta1.Query/RawParams", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// Committees queries all committess of the committee module.
	Committees(context.Context, *QueryCommitteesRequest) (*QueryCommitteesResponse, error)
	// Committee queries a committee based on committee ID.
	Committee(context.Context, *QueryCommitteeRequest) (*QueryCommitteeResponse, error)
	// Proposals queries proposals based on committee ID.
	Proposals(context.Context, *QueryProposalsRequest) (*QueryProposalsResponse, error)
	// Deposits queries a proposal based on proposal ID.
	Proposal(context.Context, *QueryProposalRequest) (*QueryProposalResponse, error)
	// NextProposalID queries the next proposal ID of the committee module.
	NextProposalID(context.Context, *QueryNextProposalIDRequest) (*QueryNextProposalIDResponse, error)
	// Votes queries all votes for a single proposal ID.
	Votes(context.Context, *QueryVotesRequest) (*QueryVotesResponse, error)
	// Vote queries the vote of a single voter for a single proposal ID.
	Vote(context.Context, *QueryVoteRequest) (*QueryVoteResponse, error)
	// Tally queries the tally of a single proposal ID.
	Tally(context.Context, *QueryTallyRequest) (*QueryTallyResponse, error)
	// RawParams queries the raw params data of any subspace and key.
	RawParams(context.Context, *QueryRawParamsRequest) (*QueryRawParamsResponse, error)
}

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

func (*UnimplementedQueryServer) Committees(ctx context.Context, req *QueryCommitteesRequest) (*QueryCommitteesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Committees not implemented")
}
func (*UnimplementedQueryServer) Committee(ctx context.Context, req *QueryCommitteeRequest) (*QueryCommitteeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Committee not implemented")
}
func (*UnimplementedQueryServer) Proposals(ctx context.Context, req *QueryProposalsRequest) (*QueryProposalsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Proposals not implemented")
}
func (*UnimplementedQueryServer) Proposal(ctx context.Context, req *QueryProposalRequest) (*QueryProposalResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Proposal not implemented")
}
func (*UnimplementedQueryServer) NextProposalID(ctx context.Context, req *QueryNextProposalIDRequest) (*QueryNextProposalIDResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NextProposalID not implemented")
}
func (*UnimplementedQueryServer) Votes(ctx context.Context, req *QueryVotesRequest) (*QueryVotesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Votes not implemented")
}
func (*UnimplementedQueryServer) Vote(ctx context.Context, req *QueryVoteRequest) (*QueryVoteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Vote not implemented")
}
func (*UnimplementedQueryServer) Tally(ctx context.Context, req *QueryTallyRequest) (*QueryTallyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Tally not implemented")
}
func (*UnimplementedQueryServer) RawParams(ctx context.Context, req *QueryRawParamsRequest) (*QueryRawParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RawParams not implemented")
}

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

func _Query_Committees_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryCommitteesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Committees(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nemo.committee.v1beta1.Query/Committees",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Committees(ctx, req.(*QueryCommitteesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Committee_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryCommitteeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Committee(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nemo.committee.v1beta1.Query/Committee",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Committee(ctx, req.(*QueryCommitteeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Proposals_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryProposalsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Proposals(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nemo.committee.v1beta1.Query/Proposals",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Proposals(ctx, req.(*QueryProposalsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Proposal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryProposalRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Proposal(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nemo.committee.v1beta1.Query/Proposal",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Proposal(ctx, req.(*QueryProposalRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_NextProposalID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryNextProposalIDRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).NextProposalID(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nemo.committee.v1beta1.Query/NextProposalID",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).NextProposalID(ctx, req.(*QueryNextProposalIDRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Votes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryVotesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Votes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nemo.committee.v1beta1.Query/Votes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Votes(ctx, req.(*QueryVotesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Vote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryVoteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Vote(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nemo.committee.v1beta1.Query/Vote",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Vote(ctx, req.(*QueryVoteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Tally_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryTallyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Tally(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nemo.committee.v1beta1.Query/Tally",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Tally(ctx, req.(*QueryTallyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_RawParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryRawParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).RawParams(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nemo.committee.v1beta1.Query/RawParams",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).RawParams(ctx, req.(*QueryRawParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "nemo.committee.v1beta1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Committees",
			Handler:    _Query_Committees_Handler,
		},
		{
			MethodName: "Committee",
			Handler:    _Query_Committee_Handler,
		},
		{
			MethodName: "Proposals",
			Handler:    _Query_Proposals_Handler,
		},
		{
			MethodName: "Proposal",
			Handler:    _Query_Proposal_Handler,
		},
		{
			MethodName: "NextProposalID",
			Handler:    _Query_NextProposalID_Handler,
		},
		{
			MethodName: "Votes",
			Handler:    _Query_Votes_Handler,
		},
		{
			MethodName: "Vote",
			Handler:    _Query_Vote_Handler,
		},
		{
			MethodName: "Tally",
			Handler:    _Query_Tally_Handler,
		},
		{
			MethodName: "RawParams",
			Handler:    _Query_RawParams_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "nemo/committee/v1beta1/query.proto",
}

func (m *QueryCommitteesRequest) 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 *QueryCommitteesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *QueryCommitteesResponse) 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 *QueryCommitteesResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryCommitteesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Committees) > 0 {
		for iNdEx := len(m.Committees) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Committees[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 *QueryCommitteeRequest) 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 *QueryCommitteeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryCommitteeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CommitteeId != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.CommitteeId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *QueryCommitteeResponse) 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 *QueryCommitteeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryCommitteeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Committee != nil {
		{
			size, err := m.Committee.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 *QueryProposalsRequest) 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 *QueryProposalsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryProposalsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CommitteeId != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.CommitteeId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *QueryProposalsResponse) 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 *QueryProposalsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryProposalsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Proposals) > 0 {
		for iNdEx := len(m.Proposals) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Proposals[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 *QueryProposalRequest) 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 *QueryProposalRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryProposalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ProposalId != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.ProposalId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *QueryProposalResponse) 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 *QueryProposalResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryProposalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Deadline, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Deadline):])
	if err2 != nil {
		return 0, err2
	}
	i -= n2
	i = encodeVarintQuery(dAtA, i, uint64(n2))
	i--
	dAtA[i] = 0x22
	if m.CommitteeID != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.CommitteeID))
		i--
		dAtA[i] = 0x18
	}
	if m.ID != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x10
	}
	if m.PubProposal != nil {
		{
			size, err := m.PubProposal.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 *QueryNextProposalIDRequest) 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 *QueryNextProposalIDRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *QueryNextProposalIDResponse) 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 *QueryNextProposalIDResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryNextProposalIDResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NextProposalID != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.NextProposalID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *QueryVotesRequest) 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 *QueryVotesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *QueryVotesResponse) 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 *QueryVotesResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryVotesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Votes) > 0 {
		for iNdEx := len(m.Votes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Votes[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 *QueryVoteRequest) 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 *QueryVoteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryVoteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Voter) > 0 {
		i -= len(m.Voter)
		copy(dAtA[i:], m.Voter)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Voter)))
		i--
		dAtA[i] = 0x12
	}
	if m.ProposalId != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.ProposalId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *QueryVoteResponse) 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 *QueryVoteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryVoteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.VoteType != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.VoteType))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Voter) > 0 {
		i -= len(m.Voter)
		copy(dAtA[i:], m.Voter)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Voter)))
		i--
		dAtA[i] = 0x12
	}
	if m.ProposalID != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.ProposalID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *QueryTallyRequest) 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 *QueryTallyRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryTallyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ProposalId != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.ProposalId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *QueryTallyResponse) 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 *QueryTallyResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryTallyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Quorum.Size()
		i -= size
		if _, err := m.Quorum.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size := m.VoteThreshold.Size()
		i -= size
		if _, err := m.VoteThreshold.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size := m.PossibleVotes.Size()
		i -= size
		if _, err := m.PossibleVotes.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size := m.CurrentVotes.Size()
		i -= size
		if _, err := m.CurrentVotes.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.NoVotes.Size()
		i -= size
		if _, err := m.NoVotes.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.YesVotes.Size()
		i -= size
		if _, err := m.YesVotes.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.ProposalID != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.ProposalID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *QueryRawParamsRequest) 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 *QueryRawParamsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *QueryRawParamsResponse) 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 *QueryRawParamsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryRawParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RawData) > 0 {
		i -= len(m.RawData)
		copy(dAtA[i:], m.RawData)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.RawData)))
		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 *QueryCommitteesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

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

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

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

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

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

func (m *QueryProposalResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PubProposal != nil {
		l = m.PubProposal.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.ID != 0 {
		n += 1 + sovQuery(uint64(m.ID))
	}
	if m.CommitteeID != 0 {
		n += 1 + sovQuery(uint64(m.CommitteeID))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Deadline)
	n += 1 + l + sovQuery(uint64(l))
	return n
}

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

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

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

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

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

func (m *QueryVoteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ProposalID != 0 {
		n += 1 + sovQuery(uint64(m.ProposalID))
	}
	l = len(m.Voter)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.VoteType != 0 {
		n += 1 + sovQuery(uint64(m.VoteType))
	}
	return n
}

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

func (m *QueryTallyResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ProposalID != 0 {
		n += 1 + sovQuery(uint64(m.ProposalID))
	}
	l = m.YesVotes.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.NoVotes.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.CurrentVotes.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.PossibleVotes.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.VoteThreshold.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.Quorum.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

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

func (m *QueryRawParamsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RawData)
	if l > 0 {
		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 *QueryCommitteesRequest) 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: QueryCommitteesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCommitteesRequest: 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 *QueryCommitteesResponse) 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: QueryCommitteesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCommitteesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Committees", 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.Committees = append(m.Committees, &types.Any{})
			if err := m.Committees[len(m.Committees)-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 *QueryCommitteeRequest) 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: QueryCommitteeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCommitteeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitteeId", wireType)
			}
			m.CommitteeId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommitteeId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *QueryCommitteeResponse) 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: QueryCommitteeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCommitteeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Committee", 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.Committee == nil {
				m.Committee = &types.Any{}
			}
			if err := m.Committee.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 *QueryProposalsRequest) 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: QueryProposalsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryProposalsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitteeId", wireType)
			}
			m.CommitteeId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommitteeId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *QueryProposalsResponse) 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: QueryProposalsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryProposalsResponse: 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
			}
			m.Proposals = append(m.Proposals, QueryProposalResponse{})
			if err := m.Proposals[len(m.Proposals)-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 *QueryProposalRequest) 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: QueryProposalRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryProposalRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProposalId", wireType)
			}
			m.ProposalId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProposalId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *QueryProposalResponse) 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: QueryProposalResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryProposalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PubProposal", 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.PubProposal == nil {
				m.PubProposal = &types.Any{}
			}
			if err := m.PubProposal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitteeID", wireType)
			}
			m.CommitteeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommitteeID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Deadline", 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.Deadline, 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 *QueryNextProposalIDRequest) 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: QueryNextProposalIDRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryNextProposalIDRequest: 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 *QueryNextProposalIDResponse) 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: QueryNextProposalIDResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryNextProposalIDResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextProposalID", wireType)
			}
			m.NextProposalID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NextProposalID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *QueryVotesRequest) 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: QueryVotesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryVotesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProposalId", wireType)
			}
			m.ProposalId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProposalId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.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 *QueryVotesResponse) 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: QueryVotesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryVotesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Votes", 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.Votes = append(m.Votes, QueryVoteResponse{})
			if err := m.Votes[len(m.Votes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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.Pagination == nil {
				m.Pagination = &query.PageResponse{}
			}
			if err := m.Pagination.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 *QueryVoteRequest) 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: QueryVoteRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryVoteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProposalId", wireType)
			}
			m.ProposalId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProposalId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Voter", 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.Voter = 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 *QueryVoteResponse) 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: QueryVoteResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryVoteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProposalID", wireType)
			}
			m.ProposalID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProposalID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Voter", 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.Voter = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VoteType", wireType)
			}
			m.VoteType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VoteType |= VoteType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *QueryTallyRequest) 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: QueryTallyRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTallyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProposalId", wireType)
			}
			m.ProposalId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProposalId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *QueryTallyResponse) 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: QueryTallyResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTallyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProposalID", wireType)
			}
			m.ProposalID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProposalID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field YesVotes", 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
			}
			if err := m.YesVotes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NoVotes", 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
			}
			if err := m.NoVotes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentVotes", 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
			}
			if err := m.CurrentVotes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PossibleVotes", 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
			}
			if err := m.PossibleVotes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VoteThreshold", 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
			}
			if err := m.VoteThreshold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Quorum", 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
			}
			if err := m.Quorum.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 *QueryRawParamsRequest) 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: QueryRawParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryRawParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subspace", 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.Subspace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", 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.Key = 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 *QueryRawParamsResponse) 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: QueryRawParamsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryRawParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawData", 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.RawData = 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")
)