query.pb.go

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

package types

import (
	context "context"
	fmt "fmt"
	_ "github.com/cosmos/cosmos-sdk/types/query"
	_ "github.com/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type QueryParamsRequest struct {
}

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

var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo

type QueryParamsResponse struct {
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}

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

var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo

func (m *QueryParamsResponse) GetParams() Params {
	if m != nil {
		return m.Params
	}
	return Params{}
}

type QueryPublisherRequest struct {
	PublisherDomain string `protobuf:"bytes,1,opt,name=publisher_domain,json=publisherDomain,proto3" json:"publisher_domain,omitempty"`
}

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

var xxx_messageInfo_QueryPublisherRequest proto.InternalMessageInfo

func (m *QueryPublisherRequest) GetPublisherDomain() string {
	if m != nil {
		return m.PublisherDomain
	}
	return ""
}

type QueryPublisherResponse struct {
	Publisher *Publisher `protobuf:"bytes,1,opt,name=publisher,proto3" json:"publisher,omitempty"`
}

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

var xxx_messageInfo_QueryPublisherResponse proto.InternalMessageInfo

func (m *QueryPublisherResponse) GetPublisher() *Publisher {
	if m != nil {
		return m.Publisher
	}
	return nil
}

type QueryPublishersRequest struct {
}

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

var xxx_messageInfo_QueryPublishersRequest proto.InternalMessageInfo

type QueryPublishersResponse struct {
	Publishers []*Publisher `protobuf:"bytes,1,rep,name=publishers,proto3" json:"publishers,omitempty"`
}

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

var xxx_messageInfo_QueryPublishersResponse proto.InternalMessageInfo

func (m *QueryPublishersResponse) GetPublishers() []*Publisher {
	if m != nil {
		return m.Publishers
	}
	return nil
}

type QuerySubscriberRequest struct {
	SubscriberAddress string `protobuf:"bytes,1,opt,name=subscriber_address,json=subscriberAddress,proto3" json:"subscriber_address,omitempty"`
}

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

var xxx_messageInfo_QuerySubscriberRequest proto.InternalMessageInfo

func (m *QuerySubscriberRequest) GetSubscriberAddress() string {
	if m != nil {
		return m.SubscriberAddress
	}
	return ""
}

type QuerySubscriberResponse struct {
	Subscriber *Subscriber `protobuf:"bytes,1,opt,name=subscriber,proto3" json:"subscriber,omitempty"`
}

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

var xxx_messageInfo_QuerySubscriberResponse proto.InternalMessageInfo

func (m *QuerySubscriberResponse) GetSubscriber() *Subscriber {
	if m != nil {
		return m.Subscriber
	}
	return nil
}

type QuerySubscribersRequest struct {
}

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

var xxx_messageInfo_QuerySubscribersRequest proto.InternalMessageInfo

type QuerySubscribersResponse struct {
	Subscribers []*Subscriber `protobuf:"bytes,1,rep,name=subscribers,proto3" json:"subscribers,omitempty"`
}

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

var xxx_messageInfo_QuerySubscribersResponse proto.InternalMessageInfo

func (m *QuerySubscribersResponse) GetSubscribers() []*Subscriber {
	if m != nil {
		return m.Subscribers
	}
	return nil
}

type QueryValidatorSubscribersRequest struct {
}

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

var xxx_messageInfo_QueryValidatorSubscribersRequest proto.InternalMessageInfo

type QueryValidatorSubscribersResponse struct {
	Subscribers []*Subscriber `protobuf:"bytes,1,rep,name=subscribers,proto3" json:"subscribers,omitempty"`
}

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

var xxx_messageInfo_QueryValidatorSubscribersResponse proto.InternalMessageInfo

func (m *QueryValidatorSubscribersResponse) GetSubscribers() []*Subscriber {
	if m != nil {
		return m.Subscribers
	}
	return nil
}

type QueryPublisherIntentRequest struct {
	PublisherDomain string `protobuf:"bytes,1,opt,name=publisher_domain,json=publisherDomain,proto3" json:"publisher_domain,omitempty"`
	SubscriptionId  string `protobuf:"bytes,2,opt,name=subscription_id,json=subscriptionId,proto3" json:"subscription_id,omitempty"`
}

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

var xxx_messageInfo_QueryPublisherIntentRequest proto.InternalMessageInfo

func (m *QueryPublisherIntentRequest) GetPublisherDomain() string {
	if m != nil {
		return m.PublisherDomain
	}
	return ""
}

func (m *QueryPublisherIntentRequest) GetSubscriptionId() string {
	if m != nil {
		return m.SubscriptionId
	}
	return ""
}

type QueryPublisherIntentResponse struct {
	PublisherIntent *PublisherIntent `protobuf:"bytes,1,opt,name=publisher_intent,json=publisherIntent,proto3" json:"publisher_intent,omitempty"`
}

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

var xxx_messageInfo_QueryPublisherIntentResponse proto.InternalMessageInfo

func (m *QueryPublisherIntentResponse) GetPublisherIntent() *PublisherIntent {
	if m != nil {
		return m.PublisherIntent
	}
	return nil
}

type QueryPublisherIntentsRequest struct {
}

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

var xxx_messageInfo_QueryPublisherIntentsRequest proto.InternalMessageInfo

type QueryPublisherIntentsResponse struct {
	PublisherIntents []*PublisherIntent `protobuf:"bytes,1,rep,name=publisher_intents,json=publisherIntents,proto3" json:"publisher_intents,omitempty"`
}

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

var xxx_messageInfo_QueryPublisherIntentsResponse proto.InternalMessageInfo

func (m *QueryPublisherIntentsResponse) GetPublisherIntents() []*PublisherIntent {
	if m != nil {
		return m.PublisherIntents
	}
	return nil
}

type QueryPublisherIntentsByPublisherDomainRequest struct {
	PublisherDomain string `protobuf:"bytes,1,opt,name=publisher_domain,json=publisherDomain,proto3" json:"publisher_domain,omitempty"`
}

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

var xxx_messageInfo_QueryPublisherIntentsByPublisherDomainRequest proto.InternalMessageInfo

func (m *QueryPublisherIntentsByPublisherDomainRequest) GetPublisherDomain() string {
	if m != nil {
		return m.PublisherDomain
	}
	return ""
}

type QueryPublisherIntentsByPublisherDomainResponse struct {
	PublisherIntents []*PublisherIntent `protobuf:"bytes,1,rep,name=publisher_intents,json=publisherIntents,proto3" json:"publisher_intents,omitempty"`
}

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

var xxx_messageInfo_QueryPublisherIntentsByPublisherDomainResponse proto.InternalMessageInfo

func (m *QueryPublisherIntentsByPublisherDomainResponse) GetPublisherIntents() []*PublisherIntent {
	if m != nil {
		return m.PublisherIntents
	}
	return nil
}

type QueryPublisherIntentsBySubscriptionIDRequest struct {
	SubscriptionId string `protobuf:"bytes,1,opt,name=subscription_id,json=subscriptionId,proto3" json:"subscription_id,omitempty"`
}

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

var xxx_messageInfo_QueryPublisherIntentsBySubscriptionIDRequest proto.InternalMessageInfo

func (m *QueryPublisherIntentsBySubscriptionIDRequest) GetSubscriptionId() string {
	if m != nil {
		return m.SubscriptionId
	}
	return ""
}

type QueryPublisherIntentsBySubscriptionIDResponse struct {
	PublisherIntents []*PublisherIntent `protobuf:"bytes,1,rep,name=publisher_intents,json=publisherIntents,proto3" json:"publisher_intents,omitempty"`
}

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

var xxx_messageInfo_QueryPublisherIntentsBySubscriptionIDResponse proto.InternalMessageInfo

func (m *QueryPublisherIntentsBySubscriptionIDResponse) GetPublisherIntents() []*PublisherIntent {
	if m != nil {
		return m.PublisherIntents
	}
	return nil
}

type QuerySubscriberIntentRequest struct {
	SubscriberAddress string `protobuf:"bytes,1,opt,name=subscriber_address,json=subscriberAddress,proto3" json:"subscriber_address,omitempty"`
	SubscriptionId    string `protobuf:"bytes,2,opt,name=subscription_id,json=subscriptionId,proto3" json:"subscription_id,omitempty"`
}

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

var xxx_messageInfo_QuerySubscriberIntentRequest proto.InternalMessageInfo

func (m *QuerySubscriberIntentRequest) GetSubscriberAddress() string {
	if m != nil {
		return m.SubscriberAddress
	}
	return ""
}

func (m *QuerySubscriberIntentRequest) GetSubscriptionId() string {
	if m != nil {
		return m.SubscriptionId
	}
	return ""
}

type QuerySubscriberIntentResponse struct {
	SubscriberIntent *SubscriberIntent `protobuf:"bytes,1,opt,name=subscriber_intent,json=subscriberIntent,proto3" json:"subscriber_intent,omitempty"`
}

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

var xxx_messageInfo_QuerySubscriberIntentResponse proto.InternalMessageInfo

func (m *QuerySubscriberIntentResponse) GetSubscriberIntent() *SubscriberIntent {
	if m != nil {
		return m.SubscriberIntent
	}
	return nil
}

type QuerySubscriberIntentsRequest struct {
}

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

var xxx_messageInfo_QuerySubscriberIntentsRequest proto.InternalMessageInfo

type QuerySubscriberIntentsResponse struct {
	SubscriberIntents []*SubscriberIntent `protobuf:"bytes,1,rep,name=subscriber_intents,json=subscriberIntents,proto3" json:"subscriber_intents,omitempty"`
}

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

var xxx_messageInfo_QuerySubscriberIntentsResponse proto.InternalMessageInfo

func (m *QuerySubscriberIntentsResponse) GetSubscriberIntents() []*SubscriberIntent {
	if m != nil {
		return m.SubscriberIntents
	}
	return nil
}

type QuerySubscriberIntentsBySubscriberAddressRequest struct {
	SubscriberAddress string `protobuf:"bytes,1,opt,name=subscriber_address,json=subscriberAddress,proto3" json:"subscriber_address,omitempty"`
}

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

var xxx_messageInfo_QuerySubscriberIntentsBySubscriberAddressRequest proto.InternalMessageInfo

func (m *QuerySubscriberIntentsBySubscriberAddressRequest) GetSubscriberAddress() string {
	if m != nil {
		return m.SubscriberAddress
	}
	return ""
}

type QuerySubscriberIntentsBySubscriberAddressResponse struct {
	SubscriberIntents []*SubscriberIntent `protobuf:"bytes,1,rep,name=subscriber_intents,json=subscriberIntents,proto3" json:"subscriber_intents,omitempty"`
}

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

var xxx_messageInfo_QuerySubscriberIntentsBySubscriberAddressResponse proto.InternalMessageInfo

func (m *QuerySubscriberIntentsBySubscriberAddressResponse) GetSubscriberIntents() []*SubscriberIntent {
	if m != nil {
		return m.SubscriberIntents
	}
	return nil
}

type QuerySubscriberIntentsBySubscriptionIDRequest struct {
	SubscriptionId string `protobuf:"bytes,1,opt,name=subscription_id,json=subscriptionId,proto3" json:"subscription_id,omitempty"`
}

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

var xxx_messageInfo_QuerySubscriberIntentsBySubscriptionIDRequest proto.InternalMessageInfo

func (m *QuerySubscriberIntentsBySubscriptionIDRequest) GetSubscriptionId() string {
	if m != nil {
		return m.SubscriptionId
	}
	return ""
}

type QuerySubscriberIntentsBySubscriptionIDResponse struct {
	SubscriberIntents []*SubscriberIntent `protobuf:"bytes,1,rep,name=subscriber_intents,json=subscriberIntents,proto3" json:"subscriber_intents,omitempty"`
}

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

var xxx_messageInfo_QuerySubscriberIntentsBySubscriptionIDResponse proto.InternalMessageInfo

func (m *QuerySubscriberIntentsBySubscriptionIDResponse) GetSubscriberIntents() []*SubscriberIntent {
	if m != nil {
		return m.SubscriberIntents
	}
	return nil
}

type QuerySubscriberIntentsByPublisherDomainRequest struct {
	PublisherDomain string `protobuf:"bytes,1,opt,name=publisher_domain,json=publisherDomain,proto3" json:"publisher_domain,omitempty"`
}

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

var xxx_messageInfo_QuerySubscriberIntentsByPublisherDomainRequest proto.InternalMessageInfo

func (m *QuerySubscriberIntentsByPublisherDomainRequest) GetPublisherDomain() string {
	if m != nil {
		return m.PublisherDomain
	}
	return ""
}

type QuerySubscriberIntentsByPublisherDomainResponse struct {
	SubscriberIntents []*SubscriberIntent `protobuf:"bytes,1,rep,name=subscriber_intents,json=subscriberIntents,proto3" json:"subscriber_intents,omitempty"`
}

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

var xxx_messageInfo_QuerySubscriberIntentsByPublisherDomainResponse proto.InternalMessageInfo

func (m *QuerySubscriberIntentsByPublisherDomainResponse) GetSubscriberIntents() []*SubscriberIntent {
	if m != nil {
		return m.SubscriberIntents
	}
	return nil
}

type QueryDefaultSubscriptionRequest struct {
	SubscriptionId string `protobuf:"bytes,1,opt,name=subscription_id,json=subscriptionId,proto3" json:"subscription_id,omitempty"`
}

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

var xxx_messageInfo_QueryDefaultSubscriptionRequest proto.InternalMessageInfo

func (m *QueryDefaultSubscriptionRequest) GetSubscriptionId() string {
	if m != nil {
		return m.SubscriptionId
	}
	return ""
}

type QueryDefaultSubscriptionResponse struct {
	DefaultSubscription *DefaultSubscription `protobuf:"bytes,1,opt,name=default_subscription,json=defaultSubscription,proto3" json:"default_subscription,omitempty"`
}

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

var xxx_messageInfo_QueryDefaultSubscriptionResponse proto.InternalMessageInfo

func (m *QueryDefaultSubscriptionResponse) GetDefaultSubscription() *DefaultSubscription {
	if m != nil {
		return m.DefaultSubscription
	}
	return nil
}

type QueryDefaultSubscriptionsRequest struct {
}

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

var xxx_messageInfo_QueryDefaultSubscriptionsRequest proto.InternalMessageInfo

type QueryDefaultSubscriptionsResponse struct {
	DefaultSubscriptions []*DefaultSubscription `protobuf:"bytes,1,rep,name=default_subscriptions,json=defaultSubscriptions,proto3" json:"default_subscriptions,omitempty"`
}

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

var xxx_messageInfo_QueryDefaultSubscriptionsResponse proto.InternalMessageInfo

func (m *QueryDefaultSubscriptionsResponse) GetDefaultSubscriptions() []*DefaultSubscription {
	if m != nil {
		return m.DefaultSubscriptions
	}
	return nil
}

func init() {
	proto.RegisterType((*QueryParamsRequest)(nil), "pubsub.v1.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "pubsub.v1.QueryParamsResponse")
	proto.RegisterType((*QueryPublisherRequest)(nil), "pubsub.v1.QueryPublisherRequest")
	proto.RegisterType((*QueryPublisherResponse)(nil), "pubsub.v1.QueryPublisherResponse")
	proto.RegisterType((*QueryPublishersRequest)(nil), "pubsub.v1.QueryPublishersRequest")
	proto.RegisterType((*QueryPublishersResponse)(nil), "pubsub.v1.QueryPublishersResponse")
	proto.RegisterType((*QuerySubscriberRequest)(nil), "pubsub.v1.QuerySubscriberRequest")
	proto.RegisterType((*QuerySubscriberResponse)(nil), "pubsub.v1.QuerySubscriberResponse")
	proto.RegisterType((*QuerySubscribersRequest)(nil), "pubsub.v1.QuerySubscribersRequest")
	proto.RegisterType((*QuerySubscribersResponse)(nil), "pubsub.v1.QuerySubscribersResponse")
	proto.RegisterType((*QueryValidatorSubscribersRequest)(nil), "pubsub.v1.QueryValidatorSubscribersRequest")
	proto.RegisterType((*QueryValidatorSubscribersResponse)(nil), "pubsub.v1.QueryValidatorSubscribersResponse")
	proto.RegisterType((*QueryPublisherIntentRequest)(nil), "pubsub.v1.QueryPublisherIntentRequest")
	proto.RegisterType((*QueryPublisherIntentResponse)(nil), "pubsub.v1.QueryPublisherIntentResponse")
	proto.RegisterType((*QueryPublisherIntentsRequest)(nil), "pubsub.v1.QueryPublisherIntentsRequest")
	proto.RegisterType((*QueryPublisherIntentsResponse)(nil), "pubsub.v1.QueryPublisherIntentsResponse")
	proto.RegisterType((*QueryPublisherIntentsByPublisherDomainRequest)(nil), "pubsub.v1.QueryPublisherIntentsByPublisherDomainRequest")
	proto.RegisterType((*QueryPublisherIntentsByPublisherDomainResponse)(nil), "pubsub.v1.QueryPublisherIntentsByPublisherDomainResponse")
	proto.RegisterType((*QueryPublisherIntentsBySubscriptionIDRequest)(nil), "pubsub.v1.QueryPublisherIntentsBySubscriptionIDRequest")
	proto.RegisterType((*QueryPublisherIntentsBySubscriptionIDResponse)(nil), "pubsub.v1.QueryPublisherIntentsBySubscriptionIDResponse")
	proto.RegisterType((*QuerySubscriberIntentRequest)(nil), "pubsub.v1.QuerySubscriberIntentRequest")
	proto.RegisterType((*QuerySubscriberIntentResponse)(nil), "pubsub.v1.QuerySubscriberIntentResponse")
	proto.RegisterType((*QuerySubscriberIntentsRequest)(nil), "pubsub.v1.QuerySubscriberIntentsRequest")
	proto.RegisterType((*QuerySubscriberIntentsResponse)(nil), "pubsub.v1.QuerySubscriberIntentsResponse")
	proto.RegisterType((*QuerySubscriberIntentsBySubscriberAddressRequest)(nil), "pubsub.v1.QuerySubscriberIntentsBySubscriberAddressRequest")
	proto.RegisterType((*QuerySubscriberIntentsBySubscriberAddressResponse)(nil), "pubsub.v1.QuerySubscriberIntentsBySubscriberAddressResponse")
	proto.RegisterType((*QuerySubscriberIntentsBySubscriptionIDRequest)(nil), "pubsub.v1.QuerySubscriberIntentsBySubscriptionIDRequest")
	proto.RegisterType((*QuerySubscriberIntentsBySubscriptionIDResponse)(nil), "pubsub.v1.QuerySubscriberIntentsBySubscriptionIDResponse")
	proto.RegisterType((*QuerySubscriberIntentsByPublisherDomainRequest)(nil), "pubsub.v1.QuerySubscriberIntentsByPublisherDomainRequest")
	proto.RegisterType((*QuerySubscriberIntentsByPublisherDomainResponse)(nil), "pubsub.v1.QuerySubscriberIntentsByPublisherDomainResponse")
	proto.RegisterType((*QueryDefaultSubscriptionRequest)(nil), "pubsub.v1.QueryDefaultSubscriptionRequest")
	proto.RegisterType((*QueryDefaultSubscriptionResponse)(nil), "pubsub.v1.QueryDefaultSubscriptionResponse")
	proto.RegisterType((*QueryDefaultSubscriptionsRequest)(nil), "pubsub.v1.QueryDefaultSubscriptionsRequest")
	proto.RegisterType((*QueryDefaultSubscriptionsResponse)(nil), "pubsub.v1.QueryDefaultSubscriptionsResponse")
}

func init() { proto.RegisterFile("pubsub/v1/query.proto", fileDescriptor_1eae429cdae9f3b6) }

var fileDescriptor_1eae429cdae9f3b6 = []byte{
	// 1285 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0xcd, 0x6f, 0x1b, 0x45,
	0x14, 0xcf, 0x16, 0xa8, 0x94, 0x57, 0xa9, 0x49, 0x5e, 0x9d, 0x92, 0x6e, 0x1a, 0x27, 0x99, 0x8a,
	0x7c, 0x35, 0xf5, 0x92, 0xd0, 0x2a, 0xfd, 0x02, 0xa9, 0x51, 0xa0, 0x1f, 0x94, 0x92, 0x26, 0xa8,
	0xa0, 0x82, 0x64, 0xad, 0xe3, 0xc5, 0x59, 0x64, 0x7b, 0x1d, 0xef, 0xda, 0x4a, 0x54, 0x22, 0x04,
	0x12, 0x77, 0x10, 0x07, 0x24, 0x0e, 0xfc, 0x01, 0xfc, 0x07, 0x48, 0x3d, 0x71, 0xea, 0xb1, 0x12,
	0x17, 0x4e, 0xa8, 0x4a, 0x38, 0x22, 0x71, 0xe0, 0xc2, 0x11, 0x65, 0xf6, 0xed, 0x87, 0x77, 0x67,
	0xbc, 0x13, 0xa7, 0xb9, 0x59, 0x33, 0x6f, 0xde, 0xfb, 0xfd, 0xde, 0xbc, 0xf7, 0xf6, 0x37, 0x86,
	0xe1, 0x46, 0xab, 0xe4, 0xb6, 0x4a, 0x46, 0x7b, 0xc1, 0xd8, 0x6a, 0x59, 0xcd, 0x9d, 0x42, 0xa3,
	0xe9, 0x78, 0x0e, 0xf6, 0xfb, 0xcb, 0x85, 0xf6, 0x82, 0x9e, 0xab, 0x38, 0x15, 0x87, 0xaf, 0x1a,
	0x07, 0xbf, 0x7c, 0x03, 0xfd, 0x7c, 0xc5, 0x71, 0x2a, 0x55, 0xcb, 0x30, 0x1b, 0xb6, 0x61, 0xd6,
	0xeb, 0x8e, 0x67, 0x7a, 0xb6, 0x53, 0x77, 0x69, 0x77, 0x6e, 0xc3, 0x71, 0x6b, 0x8e, 0x6b, 0x94,
	0x4c, 0xd7, 0xf2, 0xfd, 0x1a, 0xed, 0x85, 0x92, 0xe5, 0x99, 0x0b, 0x46, 0xc3, 0xac, 0xd8, 0x75,
	0x6e, 0x4c, 0xb6, 0x67, 0x23, 0x04, 0x0d, 0xb3, 0x69, 0xd6, 0x5c, 0xc1, 0xba, 0x0f, 0x86, 0xaf,
	0xb3, 0x1c, 0xe0, 0xc3, 0x03, 0x8f, 0xab, 0xdc, 0x78, 0xcd, 0xda, 0x6a, 0x59, 0xae, 0xc7, 0xde,
	0x83, 0x33, 0x1d, 0xab, 0x6e, 0xc3, 0xa9, 0xbb, 0x16, 0x1a, 0x70, 0xd2, 0x77, 0x3a, 0xa2, 0x4d,
	0x68, 0x33, 0xa7, 0x16, 0x87, 0x0a, 0x21, 0xb1, 0x82, 0x6f, 0xba, 0xfc, 0xea, 0xb3, 0x3f, 0xc7,
	0xfb, 0xd6, 0xc8, 0x8c, 0x2d, 0xc3, 0xb0, 0xef, 0xa7, 0x55, 0xaa, 0xda, 0xee, 0xa6, 0xd5, 0xa4,
	0x00, 0x38, 0x0b, 0x83, 0x8d, 0x60, 0xad, 0x58, 0x76, 0x6a, 0xa6, 0x5d, 0xe7, 0x3e, 0xfb, 0xd7,
	0x06, 0xc2, 0xf5, 0x15, 0xbe, 0xcc, 0xee, 0xc3, 0xd9, 0xa4, 0x0f, 0x82, 0xb3, 0x08, 0xfd, 0xa1,
	0x31, 0x21, 0xca, 0xc5, 0x11, 0x85, 0x07, 0x22, 0x33, 0x36, 0x92, 0xf4, 0x16, 0x72, 0xfe, 0x10,
	0x5e, 0x4f, 0xed, 0x50, 0xa0, 0xcb, 0x00, 0xa1, 0x87, 0x03, 0xee, 0xaf, 0x48, 0x23, 0xc5, 0xec,
	0xd8, 0x6d, 0x0a, 0xb5, 0xde, 0x2a, 0xb9, 0x1b, 0x4d, 0xbb, 0x14, 0xb1, 0xbf, 0x04, 0xe8, 0x86,
	0x8b, 0x45, 0xb3, 0x5c, 0x6e, 0x5a, 0xae, 0x4b, 0xfc, 0x87, 0xa2, 0x9d, 0x5b, 0xfe, 0x06, 0x5b,
	0x25, 0x64, 0x71, 0x47, 0x84, 0xec, 0x0a, 0x40, 0x64, 0x4f, 0x39, 0x18, 0x8e, 0x21, 0x8b, 0x1d,
	0x89, 0x19, 0xb2, 0x73, 0x29, 0x8f, 0x61, 0x1a, 0xd6, 0x61, 0x24, 0xbd, 0x45, 0xd1, 0x96, 0xe0,
	0x54, 0xe4, 0x24, 0x48, 0x84, 0x24, 0x5c, 0xdc, 0x92, 0x31, 0x98, 0xe0, 0x4e, 0x1f, 0x99, 0x55,
	0xbb, 0x6c, 0x7a, 0x4e, 0x53, 0x10, 0xf8, 0x33, 0x98, 0xec, 0x62, 0x73, 0x54, 0x04, 0x5b, 0x30,
	0xda, 0x79, 0xbb, 0x77, 0xeb, 0x9e, 0x55, 0xf7, 0x0e, 0x5f, 0x8f, 0x38, 0x0d, 0x03, 0xe4, 0xb8,
	0x71, 0xd0, 0x77, 0x45, 0xbb, 0x3c, 0x72, 0x82, 0x5b, 0x9e, 0x8e, 0x2f, 0xdf, 0x2d, 0x33, 0x0b,
	0xce, 0x8b, 0x43, 0x12, 0x97, 0x77, 0xe3, 0x31, 0x6d, 0xbe, 0x47, 0x37, 0xa8, 0x8b, 0x6a, 0x8b,
	0x4e, 0x47, 0x78, 0xfc, 0x05, 0x96, 0x17, 0x87, 0x09, 0xf3, 0xba, 0x09, 0x63, 0x92, 0x7d, 0xc2,
	0x71, 0x1b, 0x86, 0x92, 0x38, 0x82, 0xcc, 0x76, 0x03, 0x32, 0x98, 0x00, 0xe2, 0xb2, 0xc7, 0x70,
	0x49, 0x18, 0x69, 0x39, 0x5a, 0xf1, 0x73, 0xd8, 0xc3, 0x14, 0xd8, 0x81, 0x82, 0xaa, 0xef, 0x97,
	0x4d, 0xeb, 0x63, 0x98, 0x97, 0x84, 0x5e, 0x8f, 0x5f, 0xf8, 0x4a, 0xc0, 0x4a, 0x50, 0x20, 0x9a,
	0xb0, 0x40, 0xb6, 0xa5, 0xf9, 0x4a, 0x3a, 0x7e, 0xd9, 0x94, 0xda, 0x54, 0x33, 0x51, 0xb7, 0x74,
	0xb6, 0xc3, 0xe1, 0x06, 0x94, 0x7a, 0x4b, 0xd8, 0x54, 0x8b, 0xe9, 0xb8, 0xc4, 0xf0, 0x0e, 0xc4,
	0xdc, 0x77, 0x36, 0xc5, 0xa8, 0xb0, 0xcb, 0x03, 0x8a, 0x6e, 0x62, 0x85, 0x8d, 0x4b, 0x42, 0x85,
	0x7d, 0x51, 0x85, 0xbc, 0xcc, 0x80, 0xc0, 0xdc, 0xeb, 0xc8, 0x42, 0x67, 0xbe, 0xbb, 0xa2, 0x19,
	0x4a, 0xa2, 0x71, 0x99, 0x09, 0x6f, 0x8a, 0xa3, 0x2d, 0xc7, 0x96, 0x28, 0x9f, 0x3d, 0x7e, 0x26,
	0xbe, 0x82, 0x85, 0x43, 0x84, 0x38, 0x06, 0x8e, 0x9f, 0x50, 0x3d, 0xcb, 0x01, 0xf4, 0xda, 0x29,
	0x5f, 0x52, 0xf7, 0x2b, 0x78, 0x3e, 0x06, 0x5e, 0x9f, 0xca, 0xa3, 0x1f, 0x7d, 0xb0, 0xed, 0x82,
	0xa1, 0xec, 0xfc, 0x18, 0xb8, 0xdd, 0x83, 0x71, 0x1e, 0x7e, 0xc5, 0xfa, 0xdc, 0x6c, 0x55, 0xbd,
	0x78, 0x36, 0x0f, 0x7d, 0x4b, 0x2d, 0xfa, 0xca, 0x0b, 0x7d, 0x11, 0xf6, 0x87, 0x90, 0x2b, 0xfb,
	0xdb, 0xc5, 0xf8, 0x69, 0xea, 0xf1, 0x7c, 0x0c, 0xbd, 0xc8, 0xcb, 0x99, 0x72, 0x7a, 0x31, 0x14,
	0x17, 0x82, 0x03, 0x61, 0xb3, 0x6f, 0x93, 0xb8, 0x10, 0xdb, 0x10, 0xb6, 0x75, 0x18, 0x16, 0x61,
	0x0b, 0x52, 0x9b, 0x05, 0x2e, 0x27, 0x00, 0xe7, 0x2e, 0x3e, 0x1d, 0x81, 0xd7, 0x78, 0x68, 0xac,
	0xc2, 0x49, 0x5f, 0x24, 0xe3, 0x58, 0xcc, 0x53, 0x5a, 0x7d, 0xeb, 0x79, 0xd9, 0xb6, 0x8f, 0x93,
	0x5d, 0xf8, 0xe6, 0xf7, 0xbf, 0x7e, 0x38, 0x31, 0x86, 0xa3, 0x86, 0xeb, 0xd4, 0x6a, 0x56, 0xd5,
	0xb6, 0x9a, 0x46, 0x52, 0xf6, 0xe3, 0xf7, 0x1a, 0x9c, 0xee, 0xfc, 0xba, 0xe0, 0x44, 0xca, 0x6f,
	0x42, 0x96, 0xeb, 0x93, 0x5d, 0x2c, 0x28, 0xf8, 0x75, 0x1e, 0xfc, 0x32, 0x2e, 0x8a, 0x83, 0x87,
	0xf2, 0xd7, 0x78, 0x92, 0xec, 0x80, 0x5d, 0xfc, 0x5a, 0x83, 0x81, 0x84, 0xc6, 0x46, 0x79, 0xc8,
	0x30, 0x1f, 0xac, 0x9b, 0x09, 0xc1, 0x9a, 0xe6, 0xb0, 0x26, 0x71, 0x3c, 0x03, 0x16, 0xfe, 0x18,
	0x60, 0x88, 0xba, 0x23, 0x8d, 0x21, 0x25, 0xd9, 0xd3, 0x18, 0xd2, 0x62, 0x9c, 0xbd, 0xcd, 0x31,
	0x2c, 0xe1, 0x15, 0x21, 0x86, 0x98, 0x1a, 0x35, 0x9e, 0xa4, 0xe7, 0xfa, 0x2e, 0x7e, 0xab, 0xc1,
	0x60, 0x52, 0x7a, 0x63, 0x97, 0xb8, 0x61, 0x7e, 0x2e, 0x74, 0xb5, 0x21, 0x70, 0x33, 0x1c, 0x1c,
	0xc3, 0x89, 0x2c, 0x70, 0xf8, 0x8b, 0x06, 0xe7, 0xa4, 0x4a, 0x1c, 0x2f, 0x26, 0x83, 0x75, 0xd1,
	0xf4, 0xfa, 0xbc, 0x9a, 0x31, 0x41, 0x5c, 0xe4, 0x10, 0xe7, 0x71, 0x4e, 0x08, 0xb1, 0x1d, 0x1c,
	0x2d, 0xc6, 0xc1, 0x3e, 0xd5, 0x20, 0x27, 0x12, 0x51, 0x38, 0x25, 0x2d, 0x9a, 0x0e, 0xa9, 0xa3,
	0x4f, 0x67, 0xda, 0x11, 0xba, 0x75, 0x8e, 0xee, 0x03, 0x7c, 0xbf, 0x7b, 0x85, 0x05, 0xf3, 0x58,
	0x50, 0xff, 0xe1, 0xb5, 0x07, 0x73, 0x74, 0x17, 0x7f, 0xd2, 0x92, 0x2f, 0x64, 0x1a, 0xcc, 0x98,
	0x85, 0x2b, 0xcc, 0xf1, 0x4c, 0xb6, 0x21, 0x31, 0x28, 0x70, 0x06, 0x33, 0x38, 0xa5, 0xc6, 0x00,
	0x5f, 0x68, 0x30, 0xa5, 0x26, 0xba, 0xf1, 0x6a, 0x16, 0x08, 0xd9, 0xa7, 0x52, 0xbf, 0xd6, 0xc3,
	0x49, 0xe2, 0x73, 0x8b, 0xf3, 0xb9, 0x81, 0xd7, 0x7a, 0xbe, 0x11, 0xfc, 0x47, 0x83, 0x37, 0x94,
	0x34, 0x38, 0x2e, 0x65, 0xe3, 0x14, 0x8a, 0x1c, 0xfd, 0xea, 0xe1, 0x0f, 0xf6, 0x56, 0x71, 0xc5,
	0xd2, 0x4e, 0x31, 0x51, 0x60, 0x82, 0x8a, 0xfb, 0x2d, 0xa8, 0xb8, 0xa4, 0x3a, 0x48, 0x57, 0x9c,
	0xe4, 0x75, 0x90, 0xae, 0x38, 0x99, 0x9c, 0x67, 0x8f, 0x38, 0x83, 0x55, 0x7c, 0x90, 0x31, 0x74,
	0xa2, 0x2b, 0x12, 0x0c, 0x46, 0x01, 0x89, 0x9f, 0xb5, 0xd4, 0x7f, 0x2b, 0x41, 0xdf, 0x64, 0x82,
	0x0b, 0x1b, 0x67, 0x56, 0xc1, 0x92, 0x78, 0x18, 0x9c, 0xc7, 0x2c, 0x4e, 0x2b, 0xf2, 0xc0, 0xbf,
	0x35, 0x98, 0x55, 0x16, 0xe3, 0x78, 0x23, 0x13, 0x89, 0xfc, 0x95, 0xa0, 0xdf, 0xec, 0xed, 0x30,
	0x31, 0x5b, 0xe1, 0xcc, 0xde, 0xc1, 0x9b, 0x47, 0xb9, 0x21, 0xfc, 0x37, 0x98, 0x14, 0x99, 0x02,
	0x3d, 0x3d, 0x29, 0x54, 0x5f, 0x0b, 0xe9, 0x49, 0xa1, 0xfc, 0x1a, 0x60, 0x1f, 0x71, 0x96, 0x0f,
	0xf0, 0xbe, 0x22, 0x4b, 0xb5, 0x56, 0xfa, 0x4f, 0x83, 0x69, 0x45, 0xed, 0x8e, 0x2a, 0xe0, 0x25,
	0x13, 0xf2, 0x7a, 0x2f, 0x47, 0x7b, 0x6c, 0xc0, 0x03, 0xe2, 0xc9, 0x29, 0x29, 0x9a, 0x9b, 0xbf,
	0x6a, 0xf4, 0x37, 0xa1, 0x40, 0x08, 0xe3, 0x5c, 0x12, 0xb0, 0xfc, 0x71, 0xa1, 0x5f, 0x54, 0xb2,
	0x55, 0x2a, 0x56, 0xa1, 0x76, 0x17, 0x5c, 0x5b, 0xa8, 0x6f, 0x44, 0x8f, 0x01, 0x54, 0x01, 0x24,
	0xd7, 0x37, 0xdd, 0xde, 0x17, 0x19, 0xfa, 0x46, 0x08, 0x7f, 0xf9, 0xce, 0xb3, 0xbd, 0xbc, 0xf6,
	0x7c, 0x2f, 0xaf, 0xbd, 0xd8, 0xcb, 0x6b, 0xdf, 0xed, 0xe7, 0xfb, 0x9e, 0xef, 0xe7, 0xfb, 0xfe,
	0xd8, 0xcf, 0xf7, 0x3d, 0x2e, 0x54, 0x6c, 0x6f, 0xb3, 0x55, 0x2a, 0x6c, 0x38, 0x35, 0xa3, 0x61,
	0x55, 0x2a, 0x3b, 0x5f, 0xb4, 0x63, 0x7e, 0xdb, 0x4b, 0xc6, 0x76, 0xe0, 0xdc, 0xdb, 0x69, 0x58,
	0x6e, 0xe9, 0x24, 0xff, 0xc3, 0xff, 0xad, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0x86, 0x16, 0x16,
	0x32, 0xa4, 0x18, 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 {
	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
	QueryPublisher(ctx context.Context, in *QueryPublisherRequest, opts ...grpc.CallOption) (*QueryPublisherResponse, error)
	QueryPublishers(ctx context.Context, in *QueryPublishersRequest, opts ...grpc.CallOption) (*QueryPublishersResponse, error)
	QuerySubscriber(ctx context.Context, in *QuerySubscriberRequest, opts ...grpc.CallOption) (*QuerySubscriberResponse, error)
	QuerySubscribers(ctx context.Context, in *QuerySubscribersRequest, opts ...grpc.CallOption) (*QuerySubscribersResponse, error)
	QueryValidatorSubscribers(ctx context.Context, in *QueryValidatorSubscribersRequest, opts ...grpc.CallOption) (*QueryValidatorSubscribersResponse, error)
	QueryPublisherIntent(ctx context.Context, in *QueryPublisherIntentRequest, opts ...grpc.CallOption) (*QueryPublisherIntentResponse, error)
	QueryPublisherIntents(ctx context.Context, in *QueryPublisherIntentsRequest, opts ...grpc.CallOption) (*QueryPublisherIntentsResponse, error)
	QueryPublisherIntentsByPublisherDomain(ctx context.Context, in *QueryPublisherIntentsByPublisherDomainRequest, opts ...grpc.CallOption) (*QueryPublisherIntentsByPublisherDomainResponse, error)
	QueryPublisherIntentsBySubscriptionID(ctx context.Context, in *QueryPublisherIntentsBySubscriptionIDRequest, opts ...grpc.CallOption) (*QueryPublisherIntentsBySubscriptionIDResponse, error)
	QuerySubscriberIntent(ctx context.Context, in *QuerySubscriberIntentRequest, opts ...grpc.CallOption) (*QuerySubscriberIntentResponse, error)
	QuerySubscriberIntents(ctx context.Context, in *QuerySubscriberIntentsRequest, opts ...grpc.CallOption) (*QuerySubscriberIntentsResponse, error)
	QuerySubscriberIntentsBySubscriberAddress(ctx context.Context, in *QuerySubscriberIntentsBySubscriberAddressRequest, opts ...grpc.CallOption) (*QuerySubscriberIntentsBySubscriberAddressResponse, error)
	QuerySubscriberIntentsBySubscriptionID(ctx context.Context, in *QuerySubscriberIntentsBySubscriptionIDRequest, opts ...grpc.CallOption) (*QuerySubscriberIntentsBySubscriptionIDResponse, error)
	QuerySubscriberIntentsByPublisherDomain(ctx context.Context, in *QuerySubscriberIntentsByPublisherDomainRequest, opts ...grpc.CallOption) (*QuerySubscriberIntentsByPublisherDomainResponse, error)
	QueryDefaultSubscription(ctx context.Context, in *QueryDefaultSubscriptionRequest, opts ...grpc.CallOption) (*QueryDefaultSubscriptionResponse, error)
	QueryDefaultSubscriptions(ctx context.Context, in *QueryDefaultSubscriptionsRequest, opts ...grpc.CallOption) (*QueryDefaultSubscriptionsResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

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

func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
	out := new(QueryParamsResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/Params", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryPublisher(ctx context.Context, in *QueryPublisherRequest, opts ...grpc.CallOption) (*QueryPublisherResponse, error) {
	out := new(QueryPublisherResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/QueryPublisher", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryPublishers(ctx context.Context, in *QueryPublishersRequest, opts ...grpc.CallOption) (*QueryPublishersResponse, error) {
	out := new(QueryPublishersResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/QueryPublishers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QuerySubscriber(ctx context.Context, in *QuerySubscriberRequest, opts ...grpc.CallOption) (*QuerySubscriberResponse, error) {
	out := new(QuerySubscriberResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/QuerySubscriber", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QuerySubscribers(ctx context.Context, in *QuerySubscribersRequest, opts ...grpc.CallOption) (*QuerySubscribersResponse, error) {
	out := new(QuerySubscribersResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/QuerySubscribers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryValidatorSubscribers(ctx context.Context, in *QueryValidatorSubscribersRequest, opts ...grpc.CallOption) (*QueryValidatorSubscribersResponse, error) {
	out := new(QueryValidatorSubscribersResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/QueryValidatorSubscribers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryPublisherIntent(ctx context.Context, in *QueryPublisherIntentRequest, opts ...grpc.CallOption) (*QueryPublisherIntentResponse, error) {
	out := new(QueryPublisherIntentResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/QueryPublisherIntent", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryPublisherIntents(ctx context.Context, in *QueryPublisherIntentsRequest, opts ...grpc.CallOption) (*QueryPublisherIntentsResponse, error) {
	out := new(QueryPublisherIntentsResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/QueryPublisherIntents", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryPublisherIntentsByPublisherDomain(ctx context.Context, in *QueryPublisherIntentsByPublisherDomainRequest, opts ...grpc.CallOption) (*QueryPublisherIntentsByPublisherDomainResponse, error) {
	out := new(QueryPublisherIntentsByPublisherDomainResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/QueryPublisherIntentsByPublisherDomain", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryPublisherIntentsBySubscriptionID(ctx context.Context, in *QueryPublisherIntentsBySubscriptionIDRequest, opts ...grpc.CallOption) (*QueryPublisherIntentsBySubscriptionIDResponse, error) {
	out := new(QueryPublisherIntentsBySubscriptionIDResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/QueryPublisherIntentsBySubscriptionID", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QuerySubscriberIntent(ctx context.Context, in *QuerySubscriberIntentRequest, opts ...grpc.CallOption) (*QuerySubscriberIntentResponse, error) {
	out := new(QuerySubscriberIntentResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/QuerySubscriberIntent", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QuerySubscriberIntents(ctx context.Context, in *QuerySubscriberIntentsRequest, opts ...grpc.CallOption) (*QuerySubscriberIntentsResponse, error) {
	out := new(QuerySubscriberIntentsResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/QuerySubscriberIntents", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QuerySubscriberIntentsBySubscriberAddress(ctx context.Context, in *QuerySubscriberIntentsBySubscriberAddressRequest, opts ...grpc.CallOption) (*QuerySubscriberIntentsBySubscriberAddressResponse, error) {
	out := new(QuerySubscriberIntentsBySubscriberAddressResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/QuerySubscriberIntentsBySubscriberAddress", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QuerySubscriberIntentsBySubscriptionID(ctx context.Context, in *QuerySubscriberIntentsBySubscriptionIDRequest, opts ...grpc.CallOption) (*QuerySubscriberIntentsBySubscriptionIDResponse, error) {
	out := new(QuerySubscriberIntentsBySubscriptionIDResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/QuerySubscriberIntentsBySubscriptionID", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QuerySubscriberIntentsByPublisherDomain(ctx context.Context, in *QuerySubscriberIntentsByPublisherDomainRequest, opts ...grpc.CallOption) (*QuerySubscriberIntentsByPublisherDomainResponse, error) {
	out := new(QuerySubscriberIntentsByPublisherDomainResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/QuerySubscriberIntentsByPublisherDomain", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryDefaultSubscription(ctx context.Context, in *QueryDefaultSubscriptionRequest, opts ...grpc.CallOption) (*QueryDefaultSubscriptionResponse, error) {
	out := new(QueryDefaultSubscriptionResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/QueryDefaultSubscription", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryDefaultSubscriptions(ctx context.Context, in *QueryDefaultSubscriptionsRequest, opts ...grpc.CallOption) (*QueryDefaultSubscriptionsResponse, error) {
	out := new(QueryDefaultSubscriptionsResponse)
	err := c.cc.Invoke(ctx, "/pubsub.v1.Query/QueryDefaultSubscriptions", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
	QueryPublisher(context.Context, *QueryPublisherRequest) (*QueryPublisherResponse, error)
	QueryPublishers(context.Context, *QueryPublishersRequest) (*QueryPublishersResponse, error)
	QuerySubscriber(context.Context, *QuerySubscriberRequest) (*QuerySubscriberResponse, error)
	QuerySubscribers(context.Context, *QuerySubscribersRequest) (*QuerySubscribersResponse, error)
	QueryValidatorSubscribers(context.Context, *QueryValidatorSubscribersRequest) (*QueryValidatorSubscribersResponse, error)
	QueryPublisherIntent(context.Context, *QueryPublisherIntentRequest) (*QueryPublisherIntentResponse, error)
	QueryPublisherIntents(context.Context, *QueryPublisherIntentsRequest) (*QueryPublisherIntentsResponse, error)
	QueryPublisherIntentsByPublisherDomain(context.Context, *QueryPublisherIntentsByPublisherDomainRequest) (*QueryPublisherIntentsByPublisherDomainResponse, error)
	QueryPublisherIntentsBySubscriptionID(context.Context, *QueryPublisherIntentsBySubscriptionIDRequest) (*QueryPublisherIntentsBySubscriptionIDResponse, error)
	QuerySubscriberIntent(context.Context, *QuerySubscriberIntentRequest) (*QuerySubscriberIntentResponse, error)
	QuerySubscriberIntents(context.Context, *QuerySubscriberIntentsRequest) (*QuerySubscriberIntentsResponse, error)
	QuerySubscriberIntentsBySubscriberAddress(context.Context, *QuerySubscriberIntentsBySubscriberAddressRequest) (*QuerySubscriberIntentsBySubscriberAddressResponse, error)
	QuerySubscriberIntentsBySubscriptionID(context.Context, *QuerySubscriberIntentsBySubscriptionIDRequest) (*QuerySubscriberIntentsBySubscriptionIDResponse, error)
	QuerySubscriberIntentsByPublisherDomain(context.Context, *QuerySubscriberIntentsByPublisherDomainRequest) (*QuerySubscriberIntentsByPublisherDomainResponse, error)
	QueryDefaultSubscription(context.Context, *QueryDefaultSubscriptionRequest) (*QueryDefaultSubscriptionResponse, error)
	QueryDefaultSubscriptions(context.Context, *QueryDefaultSubscriptionsRequest) (*QueryDefaultSubscriptionsResponse, error)
}

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

func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}
func (*UnimplementedQueryServer) QueryPublisher(ctx context.Context, req *QueryPublisherRequest) (*QueryPublisherResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryPublisher not implemented")
}
func (*UnimplementedQueryServer) QueryPublishers(ctx context.Context, req *QueryPublishersRequest) (*QueryPublishersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryPublishers not implemented")
}
func (*UnimplementedQueryServer) QuerySubscriber(ctx context.Context, req *QuerySubscriberRequest) (*QuerySubscriberResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QuerySubscriber not implemented")
}
func (*UnimplementedQueryServer) QuerySubscribers(ctx context.Context, req *QuerySubscribersRequest) (*QuerySubscribersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QuerySubscribers not implemented")
}
func (*UnimplementedQueryServer) QueryValidatorSubscribers(ctx context.Context, req *QueryValidatorSubscribersRequest) (*QueryValidatorSubscribersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryValidatorSubscribers not implemented")
}
func (*UnimplementedQueryServer) QueryPublisherIntent(ctx context.Context, req *QueryPublisherIntentRequest) (*QueryPublisherIntentResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryPublisherIntent not implemented")
}
func (*UnimplementedQueryServer) QueryPublisherIntents(ctx context.Context, req *QueryPublisherIntentsRequest) (*QueryPublisherIntentsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryPublisherIntents not implemented")
}
func (*UnimplementedQueryServer) QueryPublisherIntentsByPublisherDomain(ctx context.Context, req *QueryPublisherIntentsByPublisherDomainRequest) (*QueryPublisherIntentsByPublisherDomainResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryPublisherIntentsByPublisherDomain not implemented")
}
func (*UnimplementedQueryServer) QueryPublisherIntentsBySubscriptionID(ctx context.Context, req *QueryPublisherIntentsBySubscriptionIDRequest) (*QueryPublisherIntentsBySubscriptionIDResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryPublisherIntentsBySubscriptionID not implemented")
}
func (*UnimplementedQueryServer) QuerySubscriberIntent(ctx context.Context, req *QuerySubscriberIntentRequest) (*QuerySubscriberIntentResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QuerySubscriberIntent not implemented")
}
func (*UnimplementedQueryServer) QuerySubscriberIntents(ctx context.Context, req *QuerySubscriberIntentsRequest) (*QuerySubscriberIntentsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QuerySubscriberIntents not implemented")
}
func (*UnimplementedQueryServer) QuerySubscriberIntentsBySubscriberAddress(ctx context.Context, req *QuerySubscriberIntentsBySubscriberAddressRequest) (*QuerySubscriberIntentsBySubscriberAddressResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QuerySubscriberIntentsBySubscriberAddress not implemented")
}
func (*UnimplementedQueryServer) QuerySubscriberIntentsBySubscriptionID(ctx context.Context, req *QuerySubscriberIntentsBySubscriptionIDRequest) (*QuerySubscriberIntentsBySubscriptionIDResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QuerySubscriberIntentsBySubscriptionID not implemented")
}
func (*UnimplementedQueryServer) QuerySubscriberIntentsByPublisherDomain(ctx context.Context, req *QuerySubscriberIntentsByPublisherDomainRequest) (*QuerySubscriberIntentsByPublisherDomainResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QuerySubscriberIntentsByPublisherDomain not implemented")
}
func (*UnimplementedQueryServer) QueryDefaultSubscription(ctx context.Context, req *QueryDefaultSubscriptionRequest) (*QueryDefaultSubscriptionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryDefaultSubscription not implemented")
}
func (*UnimplementedQueryServer) QueryDefaultSubscriptions(ctx context.Context, req *QueryDefaultSubscriptionsRequest) (*QueryDefaultSubscriptionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryDefaultSubscriptions not implemented")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "pubsub.v1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
		{
			MethodName: "QueryPublisher",
			Handler:    _Query_QueryPublisher_Handler,
		},
		{
			MethodName: "QueryPublishers",
			Handler:    _Query_QueryPublishers_Handler,
		},
		{
			MethodName: "QuerySubscriber",
			Handler:    _Query_QuerySubscriber_Handler,
		},
		{
			MethodName: "QuerySubscribers",
			Handler:    _Query_QuerySubscribers_Handler,
		},
		{
			MethodName: "QueryValidatorSubscribers",
			Handler:    _Query_QueryValidatorSubscribers_Handler,
		},
		{
			MethodName: "QueryPublisherIntent",
			Handler:    _Query_QueryPublisherIntent_Handler,
		},
		{
			MethodName: "QueryPublisherIntents",
			Handler:    _Query_QueryPublisherIntents_Handler,
		},
		{
			MethodName: "QueryPublisherIntentsByPublisherDomain",
			Handler:    _Query_QueryPublisherIntentsByPublisherDomain_Handler,
		},
		{
			MethodName: "QueryPublisherIntentsBySubscriptionID",
			Handler:    _Query_QueryPublisherIntentsBySubscriptionID_Handler,
		},
		{
			MethodName: "QuerySubscriberIntent",
			Handler:    _Query_QuerySubscriberIntent_Handler,
		},
		{
			MethodName: "QuerySubscriberIntents",
			Handler:    _Query_QuerySubscriberIntents_Handler,
		},
		{
			MethodName: "QuerySubscriberIntentsBySubscriberAddress",
			Handler:    _Query_QuerySubscriberIntentsBySubscriberAddress_Handler,
		},
		{
			MethodName: "QuerySubscriberIntentsBySubscriptionID",
			Handler:    _Query_QuerySubscriberIntentsBySubscriptionID_Handler,
		},
		{
			MethodName: "QuerySubscriberIntentsByPublisherDomain",
			Handler:    _Query_QuerySubscriberIntentsByPublisherDomain_Handler,
		},
		{
			MethodName: "QueryDefaultSubscription",
			Handler:    _Query_QueryDefaultSubscription_Handler,
		},
		{
			MethodName: "QueryDefaultSubscriptions",
			Handler:    _Query_QueryDefaultSubscriptions_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pubsub/v1/query.proto",
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *QueryDefaultSubscriptionsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.DefaultSubscriptions) > 0 {
		for _, e := range m.DefaultSubscriptions {
			l = e.Size()
			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 *QueryParamsRequest) 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: QueryParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParamsRequest: 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 *QueryParamsResponse) 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: QueryParamsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Params.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 *QueryPublisherRequest) 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: QueryPublisherRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublisherRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublisherDomain", 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.PublisherDomain = 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 *QueryPublisherResponse) 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: QueryPublisherResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublisherResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Publisher", 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.Publisher == nil {
				m.Publisher = &Publisher{}
			}
			if err := m.Publisher.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 *QueryPublishersRequest) 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: QueryPublishersRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublishersRequest: 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 *QueryPublishersResponse) 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: QueryPublishersResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublishersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Publishers", 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.Publishers = append(m.Publishers, &Publisher{})
			if err := m.Publishers[len(m.Publishers)-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 *QuerySubscriberRequest) 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: QuerySubscriberRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySubscriberRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriberAddress", 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.SubscriberAddress = 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 *QuerySubscriberResponse) 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: QuerySubscriberResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySubscriberResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subscriber", 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.Subscriber == nil {
				m.Subscriber = &Subscriber{}
			}
			if err := m.Subscriber.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 *QuerySubscribersRequest) 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: QuerySubscribersRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySubscribersRequest: 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 *QuerySubscribersResponse) 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: QuerySubscribersResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySubscribersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subscribers", 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.Subscribers = append(m.Subscribers, &Subscriber{})
			if err := m.Subscribers[len(m.Subscribers)-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 *QueryValidatorSubscribersRequest) 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: QueryValidatorSubscribersRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryValidatorSubscribersRequest: 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 *QueryValidatorSubscribersResponse) 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: QueryValidatorSubscribersResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryValidatorSubscribersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subscribers", 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.Subscribers = append(m.Subscribers, &Subscriber{})
			if err := m.Subscribers[len(m.Subscribers)-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 *QueryPublisherIntentRequest) 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: QueryPublisherIntentRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublisherIntentRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublisherDomain", 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.PublisherDomain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriptionId", 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.SubscriptionId = 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 *QueryPublisherIntentResponse) 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: QueryPublisherIntentResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublisherIntentResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublisherIntent", 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.PublisherIntent == nil {
				m.PublisherIntent = &PublisherIntent{}
			}
			if err := m.PublisherIntent.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 *QueryPublisherIntentsRequest) 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: QueryPublisherIntentsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublisherIntentsRequest: 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 *QueryPublisherIntentsResponse) 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: QueryPublisherIntentsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublisherIntentsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublisherIntents", 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.PublisherIntents = append(m.PublisherIntents, &PublisherIntent{})
			if err := m.PublisherIntents[len(m.PublisherIntents)-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 *QueryPublisherIntentsByPublisherDomainRequest) 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: QueryPublisherIntentsByPublisherDomainRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublisherIntentsByPublisherDomainRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublisherDomain", 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.PublisherDomain = 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 *QueryPublisherIntentsByPublisherDomainResponse) 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: QueryPublisherIntentsByPublisherDomainResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublisherIntentsByPublisherDomainResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublisherIntents", 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.PublisherIntents = append(m.PublisherIntents, &PublisherIntent{})
			if err := m.PublisherIntents[len(m.PublisherIntents)-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 *QueryPublisherIntentsBySubscriptionIDRequest) 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: QueryPublisherIntentsBySubscriptionIDRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublisherIntentsBySubscriptionIDRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriptionId", 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.SubscriptionId = 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 *QueryPublisherIntentsBySubscriptionIDResponse) 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: QueryPublisherIntentsBySubscriptionIDResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublisherIntentsBySubscriptionIDResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublisherIntents", 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.PublisherIntents = append(m.PublisherIntents, &PublisherIntent{})
			if err := m.PublisherIntents[len(m.PublisherIntents)-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 *QuerySubscriberIntentRequest) 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: QuerySubscriberIntentRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySubscriberIntentRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriberAddress", 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.SubscriberAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriptionId", 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.SubscriptionId = 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 *QuerySubscriberIntentResponse) 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: QuerySubscriberIntentResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySubscriberIntentResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriberIntent", 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.SubscriberIntent == nil {
				m.SubscriberIntent = &SubscriberIntent{}
			}
			if err := m.SubscriberIntent.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 *QuerySubscriberIntentsRequest) 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: QuerySubscriberIntentsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySubscriberIntentsRequest: 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 *QuerySubscriberIntentsResponse) 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: QuerySubscriberIntentsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySubscriberIntentsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriberIntents", 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.SubscriberIntents = append(m.SubscriberIntents, &SubscriberIntent{})
			if err := m.SubscriberIntents[len(m.SubscriberIntents)-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 *QuerySubscriberIntentsBySubscriberAddressRequest) 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: QuerySubscriberIntentsBySubscriberAddressRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySubscriberIntentsBySubscriberAddressRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriberAddress", 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.SubscriberAddress = 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 *QuerySubscriberIntentsBySubscriberAddressResponse) 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: QuerySubscriberIntentsBySubscriberAddressResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySubscriberIntentsBySubscriberAddressResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriberIntents", 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.SubscriberIntents = append(m.SubscriberIntents, &SubscriberIntent{})
			if err := m.SubscriberIntents[len(m.SubscriberIntents)-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 *QuerySubscriberIntentsBySubscriptionIDRequest) 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: QuerySubscriberIntentsBySubscriptionIDRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySubscriberIntentsBySubscriptionIDRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriptionId", 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.SubscriptionId = 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 *QuerySubscriberIntentsBySubscriptionIDResponse) 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: QuerySubscriberIntentsBySubscriptionIDResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySubscriberIntentsBySubscriptionIDResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriberIntents", 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.SubscriberIntents = append(m.SubscriberIntents, &SubscriberIntent{})
			if err := m.SubscriberIntents[len(m.SubscriberIntents)-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 *QuerySubscriberIntentsByPublisherDomainRequest) 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: QuerySubscriberIntentsByPublisherDomainRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySubscriberIntentsByPublisherDomainRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublisherDomain", 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.PublisherDomain = 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 *QuerySubscriberIntentsByPublisherDomainResponse) 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: QuerySubscriberIntentsByPublisherDomainResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySubscriberIntentsByPublisherDomainResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriberIntents", 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.SubscriberIntents = append(m.SubscriberIntents, &SubscriberIntent{})
			if err := m.SubscriberIntents[len(m.SubscriberIntents)-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 *QueryDefaultSubscriptionRequest) 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: QueryDefaultSubscriptionRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryDefaultSubscriptionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriptionId", 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.SubscriptionId = 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 *QueryDefaultSubscriptionResponse) 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: QueryDefaultSubscriptionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryDefaultSubscriptionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultSubscription", 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.DefaultSubscription == nil {
				m.DefaultSubscription = &DefaultSubscription{}
			}
			if err := m.DefaultSubscription.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 *QueryDefaultSubscriptionsRequest) 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: QueryDefaultSubscriptionsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryDefaultSubscriptionsRequest: 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 *QueryDefaultSubscriptionsResponse) 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: QueryDefaultSubscriptionsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryDefaultSubscriptionsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultSubscriptions", 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.DefaultSubscriptions = append(m.DefaultSubscriptions, &DefaultSubscription{})
			if err := m.DefaultSubscriptions[len(m.DefaultSubscriptions)-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 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")
)