query.pb.go

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

package credential

import (
	context "context"
	fmt "fmt"
	query "github.com/cosmos/cosmos-sdk/types/query"
	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 QueryPublicCredentialRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}

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

var xxx_messageInfo_QueryPublicCredentialRequest proto.InternalMessageInfo

func (m *QueryPublicCredentialRequest) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type QueryPublicCredentialResponse struct {
	Credential *PublicVerifiableCredential `protobuf:"bytes,1,opt,name=credential,proto3" json:"credential,omitempty"`
}

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

var xxx_messageInfo_QueryPublicCredentialResponse proto.InternalMessageInfo

func (m *QueryPublicCredentialResponse) GetCredential() *PublicVerifiableCredential {
	if m != nil {
		return m.Credential
	}
	return nil
}

type QueryPublicCredentialsRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryPublicCredentialsRequest proto.InternalMessageInfo

func (m *QueryPublicCredentialsRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

type QueryPublicCredentialsResponse struct {
	Credential []*PublicVerifiableCredential `protobuf:"bytes,1,rep,name=credential,proto3" json:"credential,omitempty"`
	Pagination *query.PageResponse           `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryPublicCredentialsResponse proto.InternalMessageInfo

func (m *QueryPublicCredentialsResponse) GetCredential() []*PublicVerifiableCredential {
	if m != nil {
		return m.Credential
	}
	return nil
}

func (m *QueryPublicCredentialsResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

type QueryAllowedPublicCredentialsRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllowedPublicCredentialsRequest proto.InternalMessageInfo

func (m *QueryAllowedPublicCredentialsRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

type QueryAllowedPublicCredentialsResponse struct {
	Credentials []*CredentialDefinition `protobuf:"bytes,1,rep,name=credentials,proto3" json:"credentials,omitempty"`
	Pagination  *query.PageResponse     `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllowedPublicCredentialsResponse proto.InternalMessageInfo

func (m *QueryAllowedPublicCredentialsResponse) GetCredentials() []*CredentialDefinition {
	if m != nil {
		return m.Credentials
	}
	return nil
}

func (m *QueryAllowedPublicCredentialsResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

type QueryPublicCredentialsByHolderRequest struct {
	Did        string             `protobuf:"bytes,1,opt,name=did,proto3" json:"did,omitempty"`
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryPublicCredentialsByHolderRequest proto.InternalMessageInfo

func (m *QueryPublicCredentialsByHolderRequest) GetDid() string {
	if m != nil {
		return m.Did
	}
	return ""
}

func (m *QueryPublicCredentialsByHolderRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

type QueryPublicCredentialsByHolderResponse struct {
	Credential []*PublicVerifiableCredential `protobuf:"bytes,1,rep,name=credential,proto3" json:"credential,omitempty"`
	Pagination *query.PageResponse           `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryPublicCredentialsByHolderResponse proto.InternalMessageInfo

func (m *QueryPublicCredentialsByHolderResponse) GetCredential() []*PublicVerifiableCredential {
	if m != nil {
		return m.Credential
	}
	return nil
}

func (m *QueryPublicCredentialsByHolderResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

type QueryPublicCredentialsByIssuerRequest struct {
	Did        string             `protobuf:"bytes,1,opt,name=did,proto3" json:"did,omitempty"`
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryPublicCredentialsByIssuerRequest proto.InternalMessageInfo

func (m *QueryPublicCredentialsByIssuerRequest) GetDid() string {
	if m != nil {
		return m.Did
	}
	return ""
}

func (m *QueryPublicCredentialsByIssuerRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

type QueryPublicCredentialsByIssuerResponse struct {
	Credential []*PublicVerifiableCredential `protobuf:"bytes,1,rep,name=credential,proto3" json:"credential,omitempty"`
	Pagination *query.PageResponse           `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryPublicCredentialsByIssuerResponse proto.InternalMessageInfo

func (m *QueryPublicCredentialsByIssuerResponse) GetCredential() []*PublicVerifiableCredential {
	if m != nil {
		return m.Credential
	}
	return nil
}

func (m *QueryPublicCredentialsByIssuerResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

type QueryCredentialDefinitionRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}

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

var xxx_messageInfo_QueryCredentialDefinitionRequest proto.InternalMessageInfo

func (m *QueryCredentialDefinitionRequest) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type QueryCredentialDefinitionResponse struct {
	Definition *CredentialDefinition `protobuf:"bytes,1,opt,name=definition,proto3" json:"definition,omitempty"`
}

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

var xxx_messageInfo_QueryCredentialDefinitionResponse proto.InternalMessageInfo

func (m *QueryCredentialDefinitionResponse) GetDefinition() *CredentialDefinition {
	if m != nil {
		return m.Definition
	}
	return nil
}

type QueryCredentialDefinitionsRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryCredentialDefinitionsRequest proto.InternalMessageInfo

func (m *QueryCredentialDefinitionsRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

type QueryCredentialDefinitionsResponse struct {
	Definitions []*CredentialDefinition `protobuf:"bytes,1,rep,name=definitions,proto3" json:"definitions,omitempty"`
	Pagination  *query.PageResponse     `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryCredentialDefinitionsResponse proto.InternalMessageInfo

func (m *QueryCredentialDefinitionsResponse) GetDefinitions() []*CredentialDefinition {
	if m != nil {
		return m.Definitions
	}
	return nil
}

func (m *QueryCredentialDefinitionsResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

type QueryCredentialDefinitionsByPublisherRequest struct {
	Did        string             `protobuf:"bytes,1,opt,name=did,proto3" json:"did,omitempty"`
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryCredentialDefinitionsByPublisherRequest proto.InternalMessageInfo

func (m *QueryCredentialDefinitionsByPublisherRequest) GetDid() string {
	if m != nil {
		return m.Did
	}
	return ""
}

func (m *QueryCredentialDefinitionsByPublisherRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

type QueryCredentialDefinitionsByPublisherResponse struct {
	Definitions []*CredentialDefinition `protobuf:"bytes,1,rep,name=definitions,proto3" json:"definitions,omitempty"`
	Pagination  *query.PageResponse     `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryCredentialDefinitionsByPublisherResponse proto.InternalMessageInfo

func (m *QueryCredentialDefinitionsByPublisherResponse) GetDefinitions() []*CredentialDefinition {
	if m != nil {
		return m.Definitions
	}
	return nil
}

func (m *QueryCredentialDefinitionsByPublisherResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

func init() {
	proto.RegisterType((*QueryPublicCredentialRequest)(nil), "elestodao.elesto.credential.v1.QueryPublicCredentialRequest")
	proto.RegisterType((*QueryPublicCredentialResponse)(nil), "elestodao.elesto.credential.v1.QueryPublicCredentialResponse")
	proto.RegisterType((*QueryPublicCredentialsRequest)(nil), "elestodao.elesto.credential.v1.QueryPublicCredentialsRequest")
	proto.RegisterType((*QueryPublicCredentialsResponse)(nil), "elestodao.elesto.credential.v1.QueryPublicCredentialsResponse")
	proto.RegisterType((*QueryAllowedPublicCredentialsRequest)(nil), "elestodao.elesto.credential.v1.QueryAllowedPublicCredentialsRequest")
	proto.RegisterType((*QueryAllowedPublicCredentialsResponse)(nil), "elestodao.elesto.credential.v1.QueryAllowedPublicCredentialsResponse")
	proto.RegisterType((*QueryPublicCredentialsByHolderRequest)(nil), "elestodao.elesto.credential.v1.QueryPublicCredentialsByHolderRequest")
	proto.RegisterType((*QueryPublicCredentialsByHolderResponse)(nil), "elestodao.elesto.credential.v1.QueryPublicCredentialsByHolderResponse")
	proto.RegisterType((*QueryPublicCredentialsByIssuerRequest)(nil), "elestodao.elesto.credential.v1.QueryPublicCredentialsByIssuerRequest")
	proto.RegisterType((*QueryPublicCredentialsByIssuerResponse)(nil), "elestodao.elesto.credential.v1.QueryPublicCredentialsByIssuerResponse")
	proto.RegisterType((*QueryCredentialDefinitionRequest)(nil), "elestodao.elesto.credential.v1.QueryCredentialDefinitionRequest")
	proto.RegisterType((*QueryCredentialDefinitionResponse)(nil), "elestodao.elesto.credential.v1.QueryCredentialDefinitionResponse")
	proto.RegisterType((*QueryCredentialDefinitionsRequest)(nil), "elestodao.elesto.credential.v1.QueryCredentialDefinitionsRequest")
	proto.RegisterType((*QueryCredentialDefinitionsResponse)(nil), "elestodao.elesto.credential.v1.QueryCredentialDefinitionsResponse")
	proto.RegisterType((*QueryCredentialDefinitionsByPublisherRequest)(nil), "elestodao.elesto.credential.v1.QueryCredentialDefinitionsByPublisherRequest")
	proto.RegisterType((*QueryCredentialDefinitionsByPublisherResponse)(nil), "elestodao.elesto.credential.v1.QueryCredentialDefinitionsByPublisherResponse")
}

func init() { proto.RegisterFile("credential/v1/query.proto", fileDescriptor_fac323b79b6e0b88) }

var fileDescriptor_fac323b79b6e0b88 = []byte{
	// 779 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x97, 0x41, 0x4f, 0xd4, 0x4e,
	0x18, 0xc6, 0x99, 0x25, 0xff, 0x7f, 0xe2, 0x8b, 0x31, 0x38, 0x4a, 0x02, 0x05, 0x9a, 0xb5, 0x08,
	0x12, 0x85, 0xd6, 0x05, 0xe3, 0xc1, 0x88, 0x91, 0x15, 0x50, 0x13, 0x4d, 0x70, 0x63, 0x38, 0x70,
	0xeb, 0x6e, 0x87, 0x65, 0x62, 0xe9, 0x2c, 0xdb, 0xee, 0x2a, 0x21, 0x1e, 0xf4, 0xe4, 0xd1, 0xc4,
	0x0f, 0x62, 0xfc, 0x10, 0x1a, 0x0e, 0x9a, 0x90, 0xe8, 0xc1, 0xa3, 0x01, 0xbf, 0x83, 0x1e, 0xcd,
	0xce, 0x4c, 0x69, 0x97, 0xdd, 0xb6, 0xa4, 0xbb, 0x68, 0xf6, 0xd6, 0x6c, 0xe7, 0x7d, 0xde, 0xe7,
	0xf7, 0xb4, 0x33, 0x6f, 0x17, 0x46, 0x4a, 0x55, 0x62, 0x11, 0xc7, 0xa3, 0xa6, 0x6d, 0xd4, 0x73,
	0xc6, 0x76, 0x8d, 0x54, 0x77, 0xf4, 0x4a, 0x95, 0x79, 0x0c, 0xab, 0xc4, 0x26, 0xae, 0xc7, 0x2c,
	0x93, 0xe9, 0xe2, 0x4a, 0x0f, 0xd6, 0xea, 0xf5, 0x9c, 0x32, 0x56, 0x66, 0xac, 0x6c, 0x13, 0xc3,
	0xac, 0x50, 0xc3, 0x74, 0x1c, 0xe6, 0x99, 0x1e, 0x65, 0x8e, 0x2b, 0xaa, 0x95, 0xab, 0x25, 0xe6,
	0x6e, 0x31, 0xd7, 0x28, 0x9a, 0x2e, 0x11, 0xb2, 0x46, 0x3d, 0x57, 0x24, 0x9e, 0x99, 0x33, 0x2a,
	0x66, 0x99, 0x3a, 0x7c, 0xb1, 0x5c, 0xab, 0x36, 0x9b, 0x08, 0xb5, 0xe1, 0xf7, 0x35, 0x1d, 0xc6,
	0x9e, 0x34, 0x14, 0x56, 0x6b, 0x45, 0x9b, 0x96, 0xee, 0x1d, 0xdd, 0x2e, 0x90, 0xed, 0x1a, 0x71,
	0x3d, 0x7c, 0x0e, 0x32, 0xd4, 0x1a, 0x46, 0x59, 0x34, 0x7d, 0xa6, 0x90, 0xa1, 0x96, 0xb6, 0x0b,
	0xe3, 0x11, 0xeb, 0xdd, 0x0a, 0x73, 0x5c, 0x82, 0xd7, 0x01, 0x82, 0x26, 0xbc, 0x70, 0x60, 0xee,
	0x96, 0x1e, 0xcf, 0xab, 0x0b, 0xb5, 0x35, 0x52, 0xa5, 0x1b, 0xd4, 0x2c, 0xda, 0x24, 0xa4, 0x1b,
	0x52, 0xd3, 0xca, 0x11, 0xcd, 0x5d, 0xdf, 0xed, 0x0a, 0x40, 0x90, 0x80, 0x6c, 0x3e, 0xa5, 0x8b,
	0xb8, 0xf4, 0x46, 0x5c, 0xba, 0x78, 0x0a, 0x32, 0x2e, 0x7d, 0xd5, 0x2c, 0x13, 0x59, 0x5b, 0x08,
	0x55, 0x6a, 0x1f, 0x11, 0xa8, 0x51, 0x9d, 0x22, 0x38, 0xfb, 0xbb, 0xc7, 0x89, 0xef, 0x37, 0x61,
	0x64, 0x38, 0xc6, 0x95, 0x44, 0x0c, 0x61, 0xac, 0x89, 0xc3, 0x81, 0xcb, 0x1c, 0x63, 0xd1, 0xb6,
	0xd9, 0x73, 0x62, 0x9d, 0x7a, 0x6e, 0x7b, 0x08, 0x26, 0x13, 0x1a, 0xca, 0xf8, 0xd6, 0x60, 0x20,
	0x00, 0x76, 0x65, 0x7e, 0x37, 0x92, 0xf2, 0x0b, 0x94, 0x96, 0xc8, 0x06, 0x75, 0x68, 0xa3, 0x69,
	0x21, 0x2c, 0xd4, 0xbd, 0xe8, 0x5e, 0xf9, 0x28, 0x2d, 0x0c, 0xf9, 0x9d, 0x07, 0xcc, 0xb6, 0x48,
	0xd5, 0x0f, 0x6f, 0x10, 0xfa, 0xad, 0xa3, 0x3d, 0xd2, 0xb8, 0x3c, 0x16, 0x67, 0x26, 0x75, 0x9c,
	0x5f, 0x10, 0x4c, 0x25, 0x79, 0xe8, 0xa5, 0xd7, 0x31, 0x2e, 0xd3, 0x87, 0xae, 0x5b, 0xfb, 0xd7,
	0x99, 0xfa, 0x1e, 0x7a, 0x29, 0xd3, 0x39, 0xc8, 0x72, 0x9c, 0xb6, 0x5b, 0x23, 0xe2, 0x10, 0xdf,
	0x81, 0x4b, 0x31, 0x35, 0x92, 0xfe, 0x29, 0x80, 0x75, 0xf4, 0xab, 0x3c, 0x13, 0xd2, 0x6d, 0xd0,
	0x90, 0x8e, 0xf6, 0x2c, 0xa6, 0xf5, 0x69, 0x1c, 0xe3, 0x5a, 0x5c, 0xb7, 0xe0, 0x2c, 0x0a, 0x1c,
	0x76, 0x78, 0x16, 0x85, 0x84, 0xba, 0xf7, 0x8c, 0xdf, 0x20, 0x98, 0x89, 0xe6, 0xc8, 0x8b, 0x57,
	0xd9, 0xdd, 0xfc, 0x1b, 0xdb, 0x67, 0x1f, 0xc1, 0xec, 0x09, 0xad, 0xf4, 0x48, 0xba, 0x73, 0xbf,
	0xcf, 0xc2, 0x7f, 0x1c, 0x09, 0xbf, 0x47, 0x70, 0xbe, 0xe5, 0x58, 0xc0, 0x0b, 0x49, 0x5e, 0x63,
	0xbf, 0x49, 0x94, 0x3b, 0x69, 0xcb, 0x85, 0x55, 0x6d, 0xf4, 0xf5, 0xd7, 0x9f, 0xef, 0x32, 0x43,
	0xf8, 0x82, 0x21, 0xaa, 0x8d, 0xf0, 0xb8, 0xfb, 0x8c, 0x60, 0x38, 0x6a, 0xd6, 0xe2, 0xa5, 0x13,
	0x75, 0x4e, 0xf8, 0x36, 0x50, 0x96, 0x3b, 0x54, 0x91, 0x18, 0x13, 0x1c, 0x63, 0x1c, 0x8f, 0xb6,
	0xc1, 0x30, 0x4c, 0x51, 0x8d, 0x3f, 0x20, 0x18, 0x3c, 0x2e, 0x81, 0x6f, 0xa7, 0x0a, 0xd0, 0xb7,
	0xbf, 0x90, 0xb2, 0x5a, 0xda, 0xce, 0x72, 0xdb, 0x0a, 0x1e, 0x6e, 0x67, 0x7b, 0x97, 0x5a, 0x2f,
	0xf1, 0x37, 0x04, 0x23, 0x91, 0xf3, 0x19, 0x2f, 0xa7, 0x7b, 0xfa, 0xc7, 0xbe, 0x31, 0x94, 0x95,
	0x4e, 0x65, 0x24, 0xce, 0x34, 0xc7, 0xd1, 0x70, 0xb6, 0x1d, 0xce, 0x26, 0x5f, 0x6b, 0xec, 0x5a,
	0x31, 0x58, 0x62, 0x44, 0xa6, 0xc7, 0x6a, 0x1a, 0xf3, 0xe9, 0xb1, 0x9a, 0x27, 0x75, 0x3c, 0x16,
	0xe5, 0x6b, 0x25, 0xd6, 0x27, 0x04, 0x43, 0x6d, 0x8f, 0x2e, 0xbc, 0x78, 0x22, 0x2f, 0x71, 0x73,
	0x4b, 0xc9, 0x77, 0x22, 0x21, 0x51, 0xa6, 0x38, 0x4a, 0x16, 0xab, 0xad, 0x28, 0x46, 0xf8, 0xf8,
	0xdb, 0x43, 0x70, 0xb1, 0x9d, 0x12, 0xbe, 0x9b, 0xda, 0x84, 0x8f, 0xb1, 0xd8, 0x81, 0x82, 0xa4,
	0xb8, 0xc6, 0x29, 0x26, 0xf1, 0x44, 0x3c, 0x85, 0xd8, 0x41, 0xbf, 0x10, 0x64, 0x93, 0xc6, 0x09,
	0x7e, 0x94, 0x3e, 0xdb, 0xd6, 0x01, 0xa9, 0x3c, 0xee, 0x92, 0x9a, 0xc4, 0xbd, 0xc9, 0x71, 0xaf,
	0x63, 0x3d, 0x01, 0xb7, 0xe2, 0x57, 0x8a, 0xb7, 0x31, 0xbf, 0xb2, 0x77, 0xa0, 0xa2, 0xfd, 0x03,
	0x15, 0xfd, 0x38, 0x50, 0xd1, 0xdb, 0x43, 0xb5, 0x6f, 0xff, 0x50, 0xed, 0xfb, 0x7e, 0xa8, 0xf6,
	0xad, 0xcf, 0x94, 0xa9, 0xb7, 0x59, 0x2b, 0xea, 0x25, 0xb6, 0x25, 0x35, 0x67, 0x2d, 0x93, 0xf9,
	0xf2, 0xf5, 0x79, 0xe3, 0x45, 0xa8, 0x47, 0xf1, 0x7f, 0xfe, 0x67, 0x7e, 0xfe, 0x4f, 0x00, 0x00,
	0x00, 0xff, 0xff, 0x7a, 0x58, 0xa4, 0x01, 0x73, 0x10, 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 {
	// TODO: to remove in favour of a third party service that indexes the credential
	// PublicCredentials
	PublicCredentials(ctx context.Context, in *QueryPublicCredentialsRequest, opts ...grpc.CallOption) (*QueryPublicCredentialsResponse, error)
	AllowedPublicCredentials(ctx context.Context, in *QueryAllowedPublicCredentialsRequest, opts ...grpc.CallOption) (*QueryAllowedPublicCredentialsResponse, error)
	// PublicCredentials
	PublicCredential(ctx context.Context, in *QueryPublicCredentialRequest, opts ...grpc.CallOption) (*QueryPublicCredentialResponse, error)
	PublicCredentialsByHolder(ctx context.Context, in *QueryPublicCredentialsByHolderRequest, opts ...grpc.CallOption) (*QueryPublicCredentialsByHolderResponse, error)
	PublicCredentialsByIssuer(ctx context.Context, in *QueryPublicCredentialsByIssuerRequest, opts ...grpc.CallOption) (*QueryPublicCredentialsByIssuerResponse, error)
	// TODO: to remove in favor of a 3rd party service that indexes the definitions
	// CredentialDefinition
	CredentialDefinitions(ctx context.Context, in *QueryCredentialDefinitionsRequest, opts ...grpc.CallOption) (*QueryCredentialDefinitionsResponse, error)
	// CredentialDefinition
	CredentialDefinition(ctx context.Context, in *QueryCredentialDefinitionRequest, opts ...grpc.CallOption) (*QueryCredentialDefinitionResponse, error)
	CredentialDefinitionsByPublisher(ctx context.Context, in *QueryCredentialDefinitionsByPublisherRequest, opts ...grpc.CallOption) (*QueryCredentialDefinitionsByPublisherResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

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

func (c *queryClient) PublicCredentials(ctx context.Context, in *QueryPublicCredentialsRequest, opts ...grpc.CallOption) (*QueryPublicCredentialsResponse, error) {
	out := new(QueryPublicCredentialsResponse)
	err := c.cc.Invoke(ctx, "/elestodao.elesto.credential.v1.Query/PublicCredentials", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) AllowedPublicCredentials(ctx context.Context, in *QueryAllowedPublicCredentialsRequest, opts ...grpc.CallOption) (*QueryAllowedPublicCredentialsResponse, error) {
	out := new(QueryAllowedPublicCredentialsResponse)
	err := c.cc.Invoke(ctx, "/elestodao.elesto.credential.v1.Query/AllowedPublicCredentials", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) PublicCredential(ctx context.Context, in *QueryPublicCredentialRequest, opts ...grpc.CallOption) (*QueryPublicCredentialResponse, error) {
	out := new(QueryPublicCredentialResponse)
	err := c.cc.Invoke(ctx, "/elestodao.elesto.credential.v1.Query/PublicCredential", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) PublicCredentialsByHolder(ctx context.Context, in *QueryPublicCredentialsByHolderRequest, opts ...grpc.CallOption) (*QueryPublicCredentialsByHolderResponse, error) {
	out := new(QueryPublicCredentialsByHolderResponse)
	err := c.cc.Invoke(ctx, "/elestodao.elesto.credential.v1.Query/PublicCredentialsByHolder", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) PublicCredentialsByIssuer(ctx context.Context, in *QueryPublicCredentialsByIssuerRequest, opts ...grpc.CallOption) (*QueryPublicCredentialsByIssuerResponse, error) {
	out := new(QueryPublicCredentialsByIssuerResponse)
	err := c.cc.Invoke(ctx, "/elestodao.elesto.credential.v1.Query/PublicCredentialsByIssuer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) CredentialDefinitions(ctx context.Context, in *QueryCredentialDefinitionsRequest, opts ...grpc.CallOption) (*QueryCredentialDefinitionsResponse, error) {
	out := new(QueryCredentialDefinitionsResponse)
	err := c.cc.Invoke(ctx, "/elestodao.elesto.credential.v1.Query/CredentialDefinitions", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) CredentialDefinition(ctx context.Context, in *QueryCredentialDefinitionRequest, opts ...grpc.CallOption) (*QueryCredentialDefinitionResponse, error) {
	out := new(QueryCredentialDefinitionResponse)
	err := c.cc.Invoke(ctx, "/elestodao.elesto.credential.v1.Query/CredentialDefinition", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) CredentialDefinitionsByPublisher(ctx context.Context, in *QueryCredentialDefinitionsByPublisherRequest, opts ...grpc.CallOption) (*QueryCredentialDefinitionsByPublisherResponse, error) {
	out := new(QueryCredentialDefinitionsByPublisherResponse)
	err := c.cc.Invoke(ctx, "/elestodao.elesto.credential.v1.Query/CredentialDefinitionsByPublisher", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// TODO: to remove in favour of a third party service that indexes the credential
	// PublicCredentials
	PublicCredentials(context.Context, *QueryPublicCredentialsRequest) (*QueryPublicCredentialsResponse, error)
	AllowedPublicCredentials(context.Context, *QueryAllowedPublicCredentialsRequest) (*QueryAllowedPublicCredentialsResponse, error)
	// PublicCredentials
	PublicCredential(context.Context, *QueryPublicCredentialRequest) (*QueryPublicCredentialResponse, error)
	PublicCredentialsByHolder(context.Context, *QueryPublicCredentialsByHolderRequest) (*QueryPublicCredentialsByHolderResponse, error)
	PublicCredentialsByIssuer(context.Context, *QueryPublicCredentialsByIssuerRequest) (*QueryPublicCredentialsByIssuerResponse, error)
	// TODO: to remove in favor of a 3rd party service that indexes the definitions
	// CredentialDefinition
	CredentialDefinitions(context.Context, *QueryCredentialDefinitionsRequest) (*QueryCredentialDefinitionsResponse, error)
	// CredentialDefinition
	CredentialDefinition(context.Context, *QueryCredentialDefinitionRequest) (*QueryCredentialDefinitionResponse, error)
	CredentialDefinitionsByPublisher(context.Context, *QueryCredentialDefinitionsByPublisherRequest) (*QueryCredentialDefinitionsByPublisherResponse, error)
}

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

func (*UnimplementedQueryServer) PublicCredentials(ctx context.Context, req *QueryPublicCredentialsRequest) (*QueryPublicCredentialsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PublicCredentials not implemented")
}
func (*UnimplementedQueryServer) AllowedPublicCredentials(ctx context.Context, req *QueryAllowedPublicCredentialsRequest) (*QueryAllowedPublicCredentialsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AllowedPublicCredentials not implemented")
}
func (*UnimplementedQueryServer) PublicCredential(ctx context.Context, req *QueryPublicCredentialRequest) (*QueryPublicCredentialResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PublicCredential not implemented")
}
func (*UnimplementedQueryServer) PublicCredentialsByHolder(ctx context.Context, req *QueryPublicCredentialsByHolderRequest) (*QueryPublicCredentialsByHolderResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PublicCredentialsByHolder not implemented")
}
func (*UnimplementedQueryServer) PublicCredentialsByIssuer(ctx context.Context, req *QueryPublicCredentialsByIssuerRequest) (*QueryPublicCredentialsByIssuerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PublicCredentialsByIssuer not implemented")
}
func (*UnimplementedQueryServer) CredentialDefinitions(ctx context.Context, req *QueryCredentialDefinitionsRequest) (*QueryCredentialDefinitionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CredentialDefinitions not implemented")
}
func (*UnimplementedQueryServer) CredentialDefinition(ctx context.Context, req *QueryCredentialDefinitionRequest) (*QueryCredentialDefinitionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CredentialDefinition not implemented")
}
func (*UnimplementedQueryServer) CredentialDefinitionsByPublisher(ctx context.Context, req *QueryCredentialDefinitionsByPublisherRequest) (*QueryCredentialDefinitionsByPublisherResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CredentialDefinitionsByPublisher not implemented")
}

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

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

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

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

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

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

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

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

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

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "elestodao.elesto.credential.v1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "PublicCredentials",
			Handler:    _Query_PublicCredentials_Handler,
		},
		{
			MethodName: "AllowedPublicCredentials",
			Handler:    _Query_AllowedPublicCredentials_Handler,
		},
		{
			MethodName: "PublicCredential",
			Handler:    _Query_PublicCredential_Handler,
		},
		{
			MethodName: "PublicCredentialsByHolder",
			Handler:    _Query_PublicCredentialsByHolder_Handler,
		},
		{
			MethodName: "PublicCredentialsByIssuer",
			Handler:    _Query_PublicCredentialsByIssuer_Handler,
		},
		{
			MethodName: "CredentialDefinitions",
			Handler:    _Query_CredentialDefinitions_Handler,
		},
		{
			MethodName: "CredentialDefinition",
			Handler:    _Query_CredentialDefinition_Handler,
		},
		{
			MethodName: "CredentialDefinitionsByPublisher",
			Handler:    _Query_CredentialDefinitionsByPublisher_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "credential/v1/query.proto",
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func 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 *QueryPublicCredentialRequest) 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: QueryPublicCredentialRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublicCredentialRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = 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 *QueryPublicCredentialResponse) 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: QueryPublicCredentialResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublicCredentialResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Credential", 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.Credential == nil {
				m.Credential = &PublicVerifiableCredential{}
			}
			if err := m.Credential.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 *QueryPublicCredentialsRequest) 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: QueryPublicCredentialsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublicCredentialsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryPublicCredentialsResponse) 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: QueryPublicCredentialsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublicCredentialsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Credential", 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.Credential = append(m.Credential, &PublicVerifiableCredential{})
			if err := m.Credential[len(m.Credential)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageResponse{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryAllowedPublicCredentialsResponse) 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: QueryAllowedPublicCredentialsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllowedPublicCredentialsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Credentials", 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.Credentials = append(m.Credentials, &CredentialDefinition{})
			if err := m.Credentials[len(m.Credentials)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageResponse{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryPublicCredentialsByHolderRequest) 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: QueryPublicCredentialsByHolderRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublicCredentialsByHolderRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Did", 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.Did = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryPublicCredentialsByHolderResponse) 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: QueryPublicCredentialsByHolderResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublicCredentialsByHolderResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Credential", 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.Credential = append(m.Credential, &PublicVerifiableCredential{})
			if err := m.Credential[len(m.Credential)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageResponse{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryPublicCredentialsByIssuerRequest) 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: QueryPublicCredentialsByIssuerRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublicCredentialsByIssuerRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Did", 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.Did = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryPublicCredentialsByIssuerResponse) 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: QueryPublicCredentialsByIssuerResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPublicCredentialsByIssuerResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Credential", 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.Credential = append(m.Credential, &PublicVerifiableCredential{})
			if err := m.Credential[len(m.Credential)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageResponse{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryCredentialDefinitionRequest) 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: QueryCredentialDefinitionRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCredentialDefinitionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = 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 *QueryCredentialDefinitionResponse) 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: QueryCredentialDefinitionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCredentialDefinitionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Definition", 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.Definition == nil {
				m.Definition = &CredentialDefinition{}
			}
			if err := m.Definition.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 *QueryCredentialDefinitionsRequest) 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: QueryCredentialDefinitionsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCredentialDefinitionsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryCredentialDefinitionsResponse) 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: QueryCredentialDefinitionsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCredentialDefinitionsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Definitions", 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.Definitions = append(m.Definitions, &CredentialDefinition{})
			if err := m.Definitions[len(m.Definitions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageResponse{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryCredentialDefinitionsByPublisherRequest) 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: QueryCredentialDefinitionsByPublisherRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCredentialDefinitionsByPublisherRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Did", 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.Did = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryCredentialDefinitionsByPublisherResponse) 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: QueryCredentialDefinitionsByPublisherResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCredentialDefinitionsByPublisherResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Definitions", 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.Definitions = append(m.Definitions, &CredentialDefinition{})
			if err := m.Definitions[len(m.Definitions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageResponse{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func 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")
)