interface.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: interface.proto

package grpcint

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

type MerkleProof_MerkleProofType int32

const (
	MerkleProof_Membership    MerkleProof_MerkleProofType = 0
	MerkleProof_NonMembership MerkleProof_MerkleProofType = 1
)

var MerkleProof_MerkleProofType_name = map[int32]string{
	0: "Membership",
	1: "NonMembership",
}

var MerkleProof_MerkleProofType_value = map[string]int32{
	"Membership":    0,
	"NonMembership": 1,
}

func (x MerkleProof_MerkleProofType) String() string {
	return proto.EnumName(MerkleProof_MerkleProofType_name, int32(x))
}

func (MerkleProof_MerkleProofType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{9, 0}
}

type EncryptionKey struct {
	Ek                   []byte   `protobuf:"bytes,1,opt,name=ek,proto3" json:"ek,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EncryptionKey) Reset()         { *m = EncryptionKey{} }
func (m *EncryptionKey) String() string { return proto.CompactTextString(m) }
func (*EncryptionKey) ProtoMessage()    {}
func (*EncryptionKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{0}
}

func (m *EncryptionKey) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EncryptionKey.Unmarshal(m, b)
}
func (m *EncryptionKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EncryptionKey.Marshal(b, m, deterministic)
}
func (m *EncryptionKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EncryptionKey.Merge(m, src)
}
func (m *EncryptionKey) XXX_Size() int {
	return xxx_messageInfo_EncryptionKey.Size(m)
}
func (m *EncryptionKey) XXX_DiscardUnknown() {
	xxx_messageInfo_EncryptionKey.DiscardUnknown(m)
}

var xxx_messageInfo_EncryptionKey proto.InternalMessageInfo

func (m *EncryptionKey) GetEk() []byte {
	if m != nil {
		return m.Ek
	}
	return nil
}

type MasterKey struct {
	Mk                   []byte   `protobuf:"bytes,1,opt,name=mk,proto3" json:"mk,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MasterKey) Reset()         { *m = MasterKey{} }
func (m *MasterKey) String() string { return proto.CompactTextString(m) }
func (*MasterKey) ProtoMessage()    {}
func (*MasterKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{1}
}

func (m *MasterKey) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MasterKey.Unmarshal(m, b)
}
func (m *MasterKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MasterKey.Marshal(b, m, deterministic)
}
func (m *MasterKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MasterKey.Merge(m, src)
}
func (m *MasterKey) XXX_Size() int {
	return xxx_messageInfo_MasterKey.Size(m)
}
func (m *MasterKey) XXX_DiscardUnknown() {
	xxx_messageInfo_MasterKey.DiscardUnknown(m)
}

var xxx_messageInfo_MasterKey proto.InternalMessageInfo

func (m *MasterKey) GetMk() []byte {
	if m != nil {
		return m.Mk
	}
	return nil
}

type Hash struct {
	Hash                 []byte   `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Hash) Reset()         { *m = Hash{} }
func (m *Hash) String() string { return proto.CompactTextString(m) }
func (*Hash) ProtoMessage()    {}
func (*Hash) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{2}
}

func (m *Hash) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Hash.Unmarshal(m, b)
}
func (m *Hash) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Hash.Marshal(b, m, deterministic)
}
func (m *Hash) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Hash.Merge(m, src)
}
func (m *Hash) XXX_Size() int {
	return xxx_messageInfo_Hash.Size(m)
}
func (m *Hash) XXX_DiscardUnknown() {
	xxx_messageInfo_Hash.DiscardUnknown(m)
}

var xxx_messageInfo_Hash proto.InternalMessageInfo

func (m *Hash) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

// TODO: how to index in the KT?
type Username struct {
	Username             []byte   `protobuf:"bytes,1,opt,name=username,proto3" json:"username,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Username) Reset()         { *m = Username{} }
func (m *Username) String() string { return proto.CompactTextString(m) }
func (*Username) ProtoMessage()    {}
func (*Username) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{3}
}

func (m *Username) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Username.Unmarshal(m, b)
}
func (m *Username) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Username.Marshal(b, m, deterministic)
}
func (m *Username) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Username.Merge(m, src)
}
func (m *Username) XXX_Size() int {
	return xxx_messageInfo_Username.Size(m)
}
func (m *Username) XXX_DiscardUnknown() {
	xxx_messageInfo_Username.DiscardUnknown(m)
}

var xxx_messageInfo_Username proto.InternalMessageInfo

func (m *Username) GetUsername() []byte {
	if m != nil {
		return m.Username
	}
	return nil
}

type OrganizationName struct {
	HashName             *Hash    `protobuf:"bytes,1,opt,name=hash_name,json=hashName,proto3" json:"hash_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OrganizationName) Reset()         { *m = OrganizationName{} }
func (m *OrganizationName) String() string { return proto.CompactTextString(m) }
func (*OrganizationName) ProtoMessage()    {}
func (*OrganizationName) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{4}
}

func (m *OrganizationName) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_OrganizationName.Unmarshal(m, b)
}
func (m *OrganizationName) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_OrganizationName.Marshal(b, m, deterministic)
}
func (m *OrganizationName) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OrganizationName.Merge(m, src)
}
func (m *OrganizationName) XXX_Size() int {
	return xxx_messageInfo_OrganizationName.Size(m)
}
func (m *OrganizationName) XXX_DiscardUnknown() {
	xxx_messageInfo_OrganizationName.DiscardUnknown(m)
}

var xxx_messageInfo_OrganizationName proto.InternalMessageInfo

func (m *OrganizationName) GetHashName() *Hash {
	if m != nil {
		return m.HashName
	}
	return nil
}

type Position struct {
	Pos                  uint64   `protobuf:"varint,1,opt,name=pos,proto3" json:"pos,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Position) Reset()         { *m = Position{} }
func (m *Position) String() string { return proto.CompactTextString(m) }
func (*Position) ProtoMessage()    {}
func (*Position) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{5}
}

func (m *Position) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Position.Unmarshal(m, b)
}
func (m *Position) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Position.Marshal(b, m, deterministic)
}
func (m *Position) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Position.Merge(m, src)
}
func (m *Position) XXX_Size() int {
	return xxx_messageInfo_Position.Size(m)
}
func (m *Position) XXX_DiscardUnknown() {
	xxx_messageInfo_Position.DiscardUnknown(m)
}

var xxx_messageInfo_Position proto.InternalMessageInfo

func (m *Position) GetPos() uint64 {
	if m != nil {
		return m.Pos
	}
	return 0
}

type IndexedEK struct {
	PublicKey            *EncryptionKey `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	Pos                  *Position      `protobuf:"bytes,2,opt,name=pos,proto3" json:"pos,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *IndexedEK) Reset()         { *m = IndexedEK{} }
func (m *IndexedEK) String() string { return proto.CompactTextString(m) }
func (*IndexedEK) ProtoMessage()    {}
func (*IndexedEK) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{6}
}

func (m *IndexedEK) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_IndexedEK.Unmarshal(m, b)
}
func (m *IndexedEK) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_IndexedEK.Marshal(b, m, deterministic)
}
func (m *IndexedEK) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IndexedEK.Merge(m, src)
}
func (m *IndexedEK) XXX_Size() int {
	return xxx_messageInfo_IndexedEK.Size(m)
}
func (m *IndexedEK) XXX_DiscardUnknown() {
	xxx_messageInfo_IndexedEK.DiscardUnknown(m)
}

var xxx_messageInfo_IndexedEK proto.InternalMessageInfo

func (m *IndexedEK) GetPublicKey() *EncryptionKey {
	if m != nil {
		return m.PublicKey
	}
	return nil
}

func (m *IndexedEK) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

type IndexedMK struct {
	MasterKey            *MasterKey `protobuf:"bytes,1,opt,name=master_key,json=masterKey,proto3" json:"master_key,omitempty"`
	Pos                  *Position  `protobuf:"bytes,2,opt,name=pos,proto3" json:"pos,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *IndexedMK) Reset()         { *m = IndexedMK{} }
func (m *IndexedMK) String() string { return proto.CompactTextString(m) }
func (*IndexedMK) ProtoMessage()    {}
func (*IndexedMK) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{7}
}

func (m *IndexedMK) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_IndexedMK.Unmarshal(m, b)
}
func (m *IndexedMK) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_IndexedMK.Marshal(b, m, deterministic)
}
func (m *IndexedMK) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IndexedMK.Merge(m, src)
}
func (m *IndexedMK) XXX_Size() int {
	return xxx_messageInfo_IndexedMK.Size(m)
}
func (m *IndexedMK) XXX_DiscardUnknown() {
	xxx_messageInfo_IndexedMK.DiscardUnknown(m)
}

var xxx_messageInfo_IndexedMK proto.InternalMessageInfo

func (m *IndexedMK) GetMasterKey() *MasterKey {
	if m != nil {
		return m.MasterKey
	}
	return nil
}

func (m *IndexedMK) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

type MerklePath struct {
	Nodes                []*Hash  `protobuf:"bytes,1,rep,name=nodes,proto3" json:"nodes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MerklePath) Reset()         { *m = MerklePath{} }
func (m *MerklePath) String() string { return proto.CompactTextString(m) }
func (*MerklePath) ProtoMessage()    {}
func (*MerklePath) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{8}
}

func (m *MerklePath) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MerklePath.Unmarshal(m, b)
}
func (m *MerklePath) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MerklePath.Marshal(b, m, deterministic)
}
func (m *MerklePath) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MerklePath.Merge(m, src)
}
func (m *MerklePath) XXX_Size() int {
	return xxx_messageInfo_MerklePath.Size(m)
}
func (m *MerklePath) XXX_DiscardUnknown() {
	xxx_messageInfo_MerklePath.DiscardUnknown(m)
}

var xxx_messageInfo_MerklePath proto.InternalMessageInfo

func (m *MerklePath) GetNodes() []*Hash {
	if m != nil {
		return m.Nodes
	}
	return nil
}

type MerkleProof struct {
	Copath    *MerklePath                 `protobuf:"bytes,1,opt,name=copath,proto3" json:"copath,omitempty"`
	ProofType MerkleProof_MerkleProofType `protobuf:"varint,2,opt,name=proof_type,json=proofType,proto3,enum=grpcint.MerkleProof_MerkleProofType" json:"proof_type,omitempty"`
	//NOTE: This can be removed if we want to further reduce the proof size.
	// Indicate the interval of the CT if needed.
	StartPos             *Position `protobuf:"bytes,3,opt,name=start_pos,json=startPos,proto3" json:"start_pos,omitempty"`
	EndPos               *Position `protobuf:"bytes,4,opt,name=end_pos,json=endPos,proto3" json:"end_pos,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *MerkleProof) Reset()         { *m = MerkleProof{} }
func (m *MerkleProof) String() string { return proto.CompactTextString(m) }
func (*MerkleProof) ProtoMessage()    {}
func (*MerkleProof) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{9}
}

func (m *MerkleProof) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MerkleProof.Unmarshal(m, b)
}
func (m *MerkleProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MerkleProof.Marshal(b, m, deterministic)
}
func (m *MerkleProof) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MerkleProof.Merge(m, src)
}
func (m *MerkleProof) XXX_Size() int {
	return xxx_messageInfo_MerkleProof.Size(m)
}
func (m *MerkleProof) XXX_DiscardUnknown() {
	xxx_messageInfo_MerkleProof.DiscardUnknown(m)
}

var xxx_messageInfo_MerkleProof proto.InternalMessageInfo

func (m *MerkleProof) GetCopath() *MerklePath {
	if m != nil {
		return m.Copath
	}
	return nil
}

func (m *MerkleProof) GetProofType() MerkleProof_MerkleProofType {
	if m != nil {
		return m.ProofType
	}
	return MerkleProof_Membership
}

func (m *MerkleProof) GetStartPos() *Position {
	if m != nil {
		return m.StartPos
	}
	return nil
}

func (m *MerkleProof) GetEndPos() *Position {
	if m != nil {
		return m.EndPos
	}
	return nil
}

type RegisterProof struct {
	KtPath               []*MerkleProof `protobuf:"bytes,1,rep,name=kt_path,json=ktPath,proto3" json:"kt_path,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *RegisterProof) Reset()         { *m = RegisterProof{} }
func (m *RegisterProof) String() string { return proto.CompactTextString(m) }
func (*RegisterProof) ProtoMessage()    {}
func (*RegisterProof) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{10}
}

func (m *RegisterProof) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RegisterProof.Unmarshal(m, b)
}
func (m *RegisterProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RegisterProof.Marshal(b, m, deterministic)
}
func (m *RegisterProof) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterProof.Merge(m, src)
}
func (m *RegisterProof) XXX_Size() int {
	return xxx_messageInfo_RegisterProof.Size(m)
}
func (m *RegisterProof) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterProof.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterProof proto.InternalMessageInfo

func (m *RegisterProof) GetKtPath() []*MerkleProof {
	if m != nil {
		return m.KtPath
	}
	return nil
}

type LookUpProof struct {
	KtPath               []*MerkleProof `protobuf:"bytes,1,rep,name=kt_path,json=ktPath,proto3" json:"kt_path,omitempty"`
	EkList               []*IndexedEK   `protobuf:"bytes,2,rep,name=ek_list,json=ekList,proto3" json:"ek_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *LookUpProof) Reset()         { *m = LookUpProof{} }
func (m *LookUpProof) String() string { return proto.CompactTextString(m) }
func (*LookUpProof) ProtoMessage()    {}
func (*LookUpProof) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{11}
}

func (m *LookUpProof) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LookUpProof.Unmarshal(m, b)
}
func (m *LookUpProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LookUpProof.Marshal(b, m, deterministic)
}
func (m *LookUpProof) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LookUpProof.Merge(m, src)
}
func (m *LookUpProof) XXX_Size() int {
	return xxx_messageInfo_LookUpProof.Size(m)
}
func (m *LookUpProof) XXX_DiscardUnknown() {
	xxx_messageInfo_LookUpProof.DiscardUnknown(m)
}

var xxx_messageInfo_LookUpProof proto.InternalMessageInfo

func (m *LookUpProof) GetKtPath() []*MerkleProof {
	if m != nil {
		return m.KtPath
	}
	return nil
}

func (m *LookUpProof) GetEkList() []*IndexedEK {
	if m != nil {
		return m.EkList
	}
	return nil
}

type AppendProof struct {
	// Used to verify each KT root is included in the CT tree.
	CtPath *MerkleProof   `protobuf:"bytes,1,opt,name=ct_path,json=ctPath,proto3" json:"ct_path,omitempty"`
	KtPath []*MerkleProof `protobuf:"bytes,2,rep,name=kt_path,json=ktPath,proto3" json:"kt_path,omitempty"`
	//NOTE: This can be removed if we want to reduce append proof size.
	Height               uint64   `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AppendProof) Reset()         { *m = AppendProof{} }
func (m *AppendProof) String() string { return proto.CompactTextString(m) }
func (*AppendProof) ProtoMessage()    {}
func (*AppendProof) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{12}
}

func (m *AppendProof) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AppendProof.Unmarshal(m, b)
}
func (m *AppendProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AppendProof.Marshal(b, m, deterministic)
}
func (m *AppendProof) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AppendProof.Merge(m, src)
}
func (m *AppendProof) XXX_Size() int {
	return xxx_messageInfo_AppendProof.Size(m)
}
func (m *AppendProof) XXX_DiscardUnknown() {
	xxx_messageInfo_AppendProof.DiscardUnknown(m)
}

var xxx_messageInfo_AppendProof proto.InternalMessageInfo

func (m *AppendProof) GetCtPath() *MerkleProof {
	if m != nil {
		return m.CtPath
	}
	return nil
}

func (m *AppendProof) GetKtPath() []*MerkleProof {
	if m != nil {
		return m.KtPath
	}
	return nil
}

func (m *AppendProof) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

type RootHash struct {
	RootHash *Hash `protobuf:"bytes,1,opt,name=root_hash,json=rootHash,proto3" json:"root_hash,omitempty"`
	//NOTE: This can be removed if we want to further reduce the proof size.
	StartPos             *Position `protobuf:"bytes,3,opt,name=start_pos,json=startPos,proto3" json:"start_pos,omitempty"`
	EndPos               *Position `protobuf:"bytes,4,opt,name=end_pos,json=endPos,proto3" json:"end_pos,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *RootHash) Reset()         { *m = RootHash{} }
func (m *RootHash) String() string { return proto.CompactTextString(m) }
func (*RootHash) ProtoMessage()    {}
func (*RootHash) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{13}
}

func (m *RootHash) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RootHash.Unmarshal(m, b)
}
func (m *RootHash) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RootHash.Marshal(b, m, deterministic)
}
func (m *RootHash) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RootHash.Merge(m, src)
}
func (m *RootHash) XXX_Size() int {
	return xxx_messageInfo_RootHash.Size(m)
}
func (m *RootHash) XXX_DiscardUnknown() {
	xxx_messageInfo_RootHash.DiscardUnknown(m)
}

var xxx_messageInfo_RootHash proto.InternalMessageInfo

func (m *RootHash) GetRootHash() *Hash {
	if m != nil {
		return m.RootHash
	}
	return nil
}

func (m *RootHash) GetStartPos() *Position {
	if m != nil {
		return m.StartPos
	}
	return nil
}

func (m *RootHash) GetEndPos() *Position {
	if m != nil {
		return m.EndPos
	}
	return nil
}

type CheckPoint struct {
	MarshaledDigest      []byte   `protobuf:"bytes,1,opt,name=marshaled_digest,json=marshaledDigest,proto3" json:"marshaled_digest,omitempty"`
	NumLeaves            uint64   `protobuf:"varint,2,opt,name=num_leaves,json=numLeaves,proto3" json:"num_leaves,omitempty"`
	Epoch                uint64   `protobuf:"varint,3,opt,name=epoch,proto3" json:"epoch,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CheckPoint) Reset()         { *m = CheckPoint{} }
func (m *CheckPoint) String() string { return proto.CompactTextString(m) }
func (*CheckPoint) ProtoMessage()    {}
func (*CheckPoint) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{14}
}

func (m *CheckPoint) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CheckPoint.Unmarshal(m, b)
}
func (m *CheckPoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CheckPoint.Marshal(b, m, deterministic)
}
func (m *CheckPoint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CheckPoint.Merge(m, src)
}
func (m *CheckPoint) XXX_Size() int {
	return xxx_messageInfo_CheckPoint.Size(m)
}
func (m *CheckPoint) XXX_DiscardUnknown() {
	xxx_messageInfo_CheckPoint.DiscardUnknown(m)
}

var xxx_messageInfo_CheckPoint proto.InternalMessageInfo

func (m *CheckPoint) GetMarshaledDigest() []byte {
	if m != nil {
		return m.MarshaledDigest
	}
	return nil
}

func (m *CheckPoint) GetNumLeaves() uint64 {
	if m != nil {
		return m.NumLeaves
	}
	return 0
}

func (m *CheckPoint) GetEpoch() uint64 {
	if m != nil {
		return m.Epoch
	}
	return 0
}

type ExtensionProof struct {
	CtPath               *MerkleProof `protobuf:"bytes,1,opt,name=ct_path,json=ctPath,proto3" json:"ct_path,omitempty"`
	RootList             []*RootHash  `protobuf:"bytes,2,rep,name=root_list,json=rootList,proto3" json:"root_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *ExtensionProof) Reset()         { *m = ExtensionProof{} }
func (m *ExtensionProof) String() string { return proto.CompactTextString(m) }
func (*ExtensionProof) ProtoMessage()    {}
func (*ExtensionProof) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{15}
}

func (m *ExtensionProof) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExtensionProof.Unmarshal(m, b)
}
func (m *ExtensionProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExtensionProof.Marshal(b, m, deterministic)
}
func (m *ExtensionProof) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExtensionProof.Merge(m, src)
}
func (m *ExtensionProof) XXX_Size() int {
	return xxx_messageInfo_ExtensionProof.Size(m)
}
func (m *ExtensionProof) XXX_DiscardUnknown() {
	xxx_messageInfo_ExtensionProof.DiscardUnknown(m)
}

var xxx_messageInfo_ExtensionProof proto.InternalMessageInfo

func (m *ExtensionProof) GetCtPath() *MerkleProof {
	if m != nil {
		return m.CtPath
	}
	return nil
}

func (m *ExtensionProof) GetRootList() []*RootHash {
	if m != nil {
		return m.RootList
	}
	return nil
}

type GetMonitoringProofForTestRequest struct {
	Usr                  *Username `protobuf:"bytes,1,opt,name=usr,proto3" json:"usr,omitempty"`
	Pos                  *Position `protobuf:"bytes,2,opt,name=pos,proto3" json:"pos,omitempty"`
	Height               uint32    `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
	Size                 uint64    `protobuf:"varint,4,opt,name=size,proto3" json:"size,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *GetMonitoringProofForTestRequest) Reset()         { *m = GetMonitoringProofForTestRequest{} }
func (m *GetMonitoringProofForTestRequest) String() string { return proto.CompactTextString(m) }
func (*GetMonitoringProofForTestRequest) ProtoMessage()    {}
func (*GetMonitoringProofForTestRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{16}
}

func (m *GetMonitoringProofForTestRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetMonitoringProofForTestRequest.Unmarshal(m, b)
}
func (m *GetMonitoringProofForTestRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetMonitoringProofForTestRequest.Marshal(b, m, deterministic)
}
func (m *GetMonitoringProofForTestRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetMonitoringProofForTestRequest.Merge(m, src)
}
func (m *GetMonitoringProofForTestRequest) XXX_Size() int {
	return xxx_messageInfo_GetMonitoringProofForTestRequest.Size(m)
}
func (m *GetMonitoringProofForTestRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetMonitoringProofForTestRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetMonitoringProofForTestRequest proto.InternalMessageInfo

func (m *GetMonitoringProofForTestRequest) GetUsr() *Username {
	if m != nil {
		return m.Usr
	}
	return nil
}

func (m *GetMonitoringProofForTestRequest) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

func (m *GetMonitoringProofForTestRequest) GetHeight() uint32 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *GetMonitoringProofForTestRequest) GetSize() uint64 {
	if m != nil {
		return m.Size
	}
	return 0
}

type GetMonitoringProofForTestResponse struct {
	Proof                []byte   `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetMonitoringProofForTestResponse) Reset()         { *m = GetMonitoringProofForTestResponse{} }
func (m *GetMonitoringProofForTestResponse) String() string { return proto.CompactTextString(m) }
func (*GetMonitoringProofForTestResponse) ProtoMessage()    {}
func (*GetMonitoringProofForTestResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{17}
}

func (m *GetMonitoringProofForTestResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetMonitoringProofForTestResponse.Unmarshal(m, b)
}
func (m *GetMonitoringProofForTestResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetMonitoringProofForTestResponse.Marshal(b, m, deterministic)
}
func (m *GetMonitoringProofForTestResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetMonitoringProofForTestResponse.Merge(m, src)
}
func (m *GetMonitoringProofForTestResponse) XXX_Size() int {
	return xxx_messageInfo_GetMonitoringProofForTestResponse.Size(m)
}
func (m *GetMonitoringProofForTestResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetMonitoringProofForTestResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetMonitoringProofForTestResponse proto.InternalMessageInfo

func (m *GetMonitoringProofForTestResponse) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

type RegisterRequest struct {
	Usr                  *Username  `protobuf:"bytes,1,opt,name=usr,proto3" json:"usr,omitempty"`
	Key                  *MasterKey `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	Signature            []byte     `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *RegisterRequest) Reset()         { *m = RegisterRequest{} }
func (m *RegisterRequest) String() string { return proto.CompactTextString(m) }
func (*RegisterRequest) ProtoMessage()    {}
func (*RegisterRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{18}
}

func (m *RegisterRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RegisterRequest.Unmarshal(m, b)
}
func (m *RegisterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RegisterRequest.Marshal(b, m, deterministic)
}
func (m *RegisterRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterRequest.Merge(m, src)
}
func (m *RegisterRequest) XXX_Size() int {
	return xxx_messageInfo_RegisterRequest.Size(m)
}
func (m *RegisterRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterRequest proto.InternalMessageInfo

func (m *RegisterRequest) GetUsr() *Username {
	if m != nil {
		return m.Usr
	}
	return nil
}

func (m *RegisterRequest) GetKey() *MasterKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *RegisterRequest) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

type RegisterResponse struct {
	VrfKey               []byte    `protobuf:"bytes,1,opt,name=vrf_key,json=vrfKey,proto3" json:"vrf_key,omitempty"`
	Pos                  *Position `protobuf:"bytes,2,opt,name=pos,proto3" json:"pos,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *RegisterResponse) Reset()         { *m = RegisterResponse{} }
func (m *RegisterResponse) String() string { return proto.CompactTextString(m) }
func (*RegisterResponse) ProtoMessage()    {}
func (*RegisterResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{19}
}

func (m *RegisterResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RegisterResponse.Unmarshal(m, b)
}
func (m *RegisterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RegisterResponse.Marshal(b, m, deterministic)
}
func (m *RegisterResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterResponse.Merge(m, src)
}
func (m *RegisterResponse) XXX_Size() int {
	return xxx_messageInfo_RegisterResponse.Size(m)
}
func (m *RegisterResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterResponse proto.InternalMessageInfo

func (m *RegisterResponse) GetVrfKey() []byte {
	if m != nil {
		return m.VrfKey
	}
	return nil
}

func (m *RegisterResponse) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

type AppendRequest struct {
	Usr                  *Username      `protobuf:"bytes,1,opt,name=usr,proto3" json:"usr,omitempty"`
	Ek                   *EncryptionKey `protobuf:"bytes,2,opt,name=ek,proto3" json:"ek,omitempty"`
	Signature            []byte         `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *AppendRequest) Reset()         { *m = AppendRequest{} }
func (m *AppendRequest) String() string { return proto.CompactTextString(m) }
func (*AppendRequest) ProtoMessage()    {}
func (*AppendRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{20}
}

func (m *AppendRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AppendRequest.Unmarshal(m, b)
}
func (m *AppendRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AppendRequest.Marshal(b, m, deterministic)
}
func (m *AppendRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AppendRequest.Merge(m, src)
}
func (m *AppendRequest) XXX_Size() int {
	return xxx_messageInfo_AppendRequest.Size(m)
}
func (m *AppendRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AppendRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AppendRequest proto.InternalMessageInfo

func (m *AppendRequest) GetUsr() *Username {
	if m != nil {
		return m.Usr
	}
	return nil
}

func (m *AppendRequest) GetEk() *EncryptionKey {
	if m != nil {
		return m.Ek
	}
	return nil
}

func (m *AppendRequest) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

type AppendResponse struct {
	Pos                  *Position `protobuf:"bytes,1,opt,name=pos,proto3" json:"pos,omitempty"`
	VrfKey               []byte    `protobuf:"bytes,2,opt,name=vrf_key,json=vrfKey,proto3" json:"vrf_key,omitempty"`
	Completed            bool      `protobuf:"varint,3,opt,name=completed,proto3" json:"completed,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *AppendResponse) Reset()         { *m = AppendResponse{} }
func (m *AppendResponse) String() string { return proto.CompactTextString(m) }
func (*AppendResponse) ProtoMessage()    {}
func (*AppendResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{21}
}

func (m *AppendResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AppendResponse.Unmarshal(m, b)
}
func (m *AppendResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AppendResponse.Marshal(b, m, deterministic)
}
func (m *AppendResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AppendResponse.Merge(m, src)
}
func (m *AppendResponse) XXX_Size() int {
	return xxx_messageInfo_AppendResponse.Size(m)
}
func (m *AppendResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AppendResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AppendResponse proto.InternalMessageInfo

func (m *AppendResponse) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

func (m *AppendResponse) GetVrfKey() []byte {
	if m != nil {
		return m.VrfKey
	}
	return nil
}

func (m *AppendResponse) GetCompleted() bool {
	if m != nil {
		return m.Completed
	}
	return false
}

type LookUpMKRequest struct {
	Usr                  *Username `protobuf:"bytes,1,opt,name=usr,proto3" json:"usr,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *LookUpMKRequest) Reset()         { *m = LookUpMKRequest{} }
func (m *LookUpMKRequest) String() string { return proto.CompactTextString(m) }
func (*LookUpMKRequest) ProtoMessage()    {}
func (*LookUpMKRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{22}
}

func (m *LookUpMKRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LookUpMKRequest.Unmarshal(m, b)
}
func (m *LookUpMKRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LookUpMKRequest.Marshal(b, m, deterministic)
}
func (m *LookUpMKRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LookUpMKRequest.Merge(m, src)
}
func (m *LookUpMKRequest) XXX_Size() int {
	return xxx_messageInfo_LookUpMKRequest.Size(m)
}
func (m *LookUpMKRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LookUpMKRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LookUpMKRequest proto.InternalMessageInfo

func (m *LookUpMKRequest) GetUsr() *Username {
	if m != nil {
		return m.Usr
	}
	return nil
}

type LookUpMKResponse struct {
	Imk                  *IndexedMK `protobuf:"bytes,1,opt,name=imk,proto3" json:"imk,omitempty"`
	Signature            []byte     `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	VrfKey               []byte     `protobuf:"bytes,3,opt,name=vrf_key,json=vrfKey,proto3" json:"vrf_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *LookUpMKResponse) Reset()         { *m = LookUpMKResponse{} }
func (m *LookUpMKResponse) String() string { return proto.CompactTextString(m) }
func (*LookUpMKResponse) ProtoMessage()    {}
func (*LookUpMKResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{23}
}

func (m *LookUpMKResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LookUpMKResponse.Unmarshal(m, b)
}
func (m *LookUpMKResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LookUpMKResponse.Marshal(b, m, deterministic)
}
func (m *LookUpMKResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LookUpMKResponse.Merge(m, src)
}
func (m *LookUpMKResponse) XXX_Size() int {
	return xxx_messageInfo_LookUpMKResponse.Size(m)
}
func (m *LookUpMKResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_LookUpMKResponse.DiscardUnknown(m)
}

var xxx_messageInfo_LookUpMKResponse proto.InternalMessageInfo

func (m *LookUpMKResponse) GetImk() *IndexedMK {
	if m != nil {
		return m.Imk
	}
	return nil
}

func (m *LookUpMKResponse) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *LookUpMKResponse) GetVrfKey() []byte {
	if m != nil {
		return m.VrfKey
	}
	return nil
}

type LookUpMKVerifyRequest struct {
	Usr                  *Username `protobuf:"bytes,1,opt,name=usr,proto3" json:"usr,omitempty"`
	Size                 uint64    `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *LookUpMKVerifyRequest) Reset()         { *m = LookUpMKVerifyRequest{} }
func (m *LookUpMKVerifyRequest) String() string { return proto.CompactTextString(m) }
func (*LookUpMKVerifyRequest) ProtoMessage()    {}
func (*LookUpMKVerifyRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{24}
}

func (m *LookUpMKVerifyRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LookUpMKVerifyRequest.Unmarshal(m, b)
}
func (m *LookUpMKVerifyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LookUpMKVerifyRequest.Marshal(b, m, deterministic)
}
func (m *LookUpMKVerifyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LookUpMKVerifyRequest.Merge(m, src)
}
func (m *LookUpMKVerifyRequest) XXX_Size() int {
	return xxx_messageInfo_LookUpMKVerifyRequest.Size(m)
}
func (m *LookUpMKVerifyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LookUpMKVerifyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LookUpMKVerifyRequest proto.InternalMessageInfo

func (m *LookUpMKVerifyRequest) GetUsr() *Username {
	if m != nil {
		return m.Usr
	}
	return nil
}

func (m *LookUpMKVerifyRequest) GetSize() uint64 {
	if m != nil {
		return m.Size
	}
	return 0
}

type LookUpMKVerifyResponse struct {
	Imk                  *IndexedMK `protobuf:"bytes,1,opt,name=imk,proto3" json:"imk,omitempty"`
	Signature            []byte     `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	VrfKey               []byte     `protobuf:"bytes,3,opt,name=vrf_key,json=vrfKey,proto3" json:"vrf_key,omitempty"`
	Proof                []byte     `protobuf:"bytes,4,opt,name=proof,proto3" json:"proof,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *LookUpMKVerifyResponse) Reset()         { *m = LookUpMKVerifyResponse{} }
func (m *LookUpMKVerifyResponse) String() string { return proto.CompactTextString(m) }
func (*LookUpMKVerifyResponse) ProtoMessage()    {}
func (*LookUpMKVerifyResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{25}
}

func (m *LookUpMKVerifyResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LookUpMKVerifyResponse.Unmarshal(m, b)
}
func (m *LookUpMKVerifyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LookUpMKVerifyResponse.Marshal(b, m, deterministic)
}
func (m *LookUpMKVerifyResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LookUpMKVerifyResponse.Merge(m, src)
}
func (m *LookUpMKVerifyResponse) XXX_Size() int {
	return xxx_messageInfo_LookUpMKVerifyResponse.Size(m)
}
func (m *LookUpMKVerifyResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_LookUpMKVerifyResponse.DiscardUnknown(m)
}

var xxx_messageInfo_LookUpMKVerifyResponse proto.InternalMessageInfo

func (m *LookUpMKVerifyResponse) GetImk() *IndexedMK {
	if m != nil {
		return m.Imk
	}
	return nil
}

func (m *LookUpMKVerifyResponse) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *LookUpMKVerifyResponse) GetVrfKey() []byte {
	if m != nil {
		return m.VrfKey
	}
	return nil
}

func (m *LookUpMKVerifyResponse) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

type LookUpPKRequest struct {
	Usr                  *Username `protobuf:"bytes,1,opt,name=usr,proto3" json:"usr,omitempty"`
	Pos                  *Position `protobuf:"bytes,2,opt,name=pos,proto3" json:"pos,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *LookUpPKRequest) Reset()         { *m = LookUpPKRequest{} }
func (m *LookUpPKRequest) String() string { return proto.CompactTextString(m) }
func (*LookUpPKRequest) ProtoMessage()    {}
func (*LookUpPKRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{26}
}

func (m *LookUpPKRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LookUpPKRequest.Unmarshal(m, b)
}
func (m *LookUpPKRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LookUpPKRequest.Marshal(b, m, deterministic)
}
func (m *LookUpPKRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LookUpPKRequest.Merge(m, src)
}
func (m *LookUpPKRequest) XXX_Size() int {
	return xxx_messageInfo_LookUpPKRequest.Size(m)
}
func (m *LookUpPKRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LookUpPKRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LookUpPKRequest proto.InternalMessageInfo

func (m *LookUpPKRequest) GetUsr() *Username {
	if m != nil {
		return m.Usr
	}
	return nil
}

func (m *LookUpPKRequest) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

type LookUpPKResponse struct {
	Iek                  *IndexedEK `protobuf:"bytes,1,opt,name=iek,proto3" json:"iek,omitempty"`
	Signature            []byte     `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	VrfKey               []byte     `protobuf:"bytes,3,opt,name=vrf_key,json=vrfKey,proto3" json:"vrf_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *LookUpPKResponse) Reset()         { *m = LookUpPKResponse{} }
func (m *LookUpPKResponse) String() string { return proto.CompactTextString(m) }
func (*LookUpPKResponse) ProtoMessage()    {}
func (*LookUpPKResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{27}
}

func (m *LookUpPKResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LookUpPKResponse.Unmarshal(m, b)
}
func (m *LookUpPKResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LookUpPKResponse.Marshal(b, m, deterministic)
}
func (m *LookUpPKResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LookUpPKResponse.Merge(m, src)
}
func (m *LookUpPKResponse) XXX_Size() int {
	return xxx_messageInfo_LookUpPKResponse.Size(m)
}
func (m *LookUpPKResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_LookUpPKResponse.DiscardUnknown(m)
}

var xxx_messageInfo_LookUpPKResponse proto.InternalMessageInfo

func (m *LookUpPKResponse) GetIek() *IndexedEK {
	if m != nil {
		return m.Iek
	}
	return nil
}

func (m *LookUpPKResponse) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *LookUpPKResponse) GetVrfKey() []byte {
	if m != nil {
		return m.VrfKey
	}
	return nil
}

type LookUpPKVerifyRequest struct {
	Usr                  *Username `protobuf:"bytes,1,opt,name=usr,proto3" json:"usr,omitempty"`
	Size                 uint64    `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *LookUpPKVerifyRequest) Reset()         { *m = LookUpPKVerifyRequest{} }
func (m *LookUpPKVerifyRequest) String() string { return proto.CompactTextString(m) }
func (*LookUpPKVerifyRequest) ProtoMessage()    {}
func (*LookUpPKVerifyRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{28}
}

func (m *LookUpPKVerifyRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LookUpPKVerifyRequest.Unmarshal(m, b)
}
func (m *LookUpPKVerifyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LookUpPKVerifyRequest.Marshal(b, m, deterministic)
}
func (m *LookUpPKVerifyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LookUpPKVerifyRequest.Merge(m, src)
}
func (m *LookUpPKVerifyRequest) XXX_Size() int {
	return xxx_messageInfo_LookUpPKVerifyRequest.Size(m)
}
func (m *LookUpPKVerifyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LookUpPKVerifyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LookUpPKVerifyRequest proto.InternalMessageInfo

func (m *LookUpPKVerifyRequest) GetUsr() *Username {
	if m != nil {
		return m.Usr
	}
	return nil
}

func (m *LookUpPKVerifyRequest) GetSize() uint64 {
	if m != nil {
		return m.Size
	}
	return 0
}

type LookUpPKVerifyResponse struct {
	Iek                  *IndexedEK `protobuf:"bytes,1,opt,name=iek,proto3" json:"iek,omitempty"`
	Signature            []byte     `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	VrfKey               []byte     `protobuf:"bytes,3,opt,name=vrf_key,json=vrfKey,proto3" json:"vrf_key,omitempty"`
	Proof                []byte     `protobuf:"bytes,4,opt,name=proof,proto3" json:"proof,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *LookUpPKVerifyResponse) Reset()         { *m = LookUpPKVerifyResponse{} }
func (m *LookUpPKVerifyResponse) String() string { return proto.CompactTextString(m) }
func (*LookUpPKVerifyResponse) ProtoMessage()    {}
func (*LookUpPKVerifyResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{29}
}

func (m *LookUpPKVerifyResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LookUpPKVerifyResponse.Unmarshal(m, b)
}
func (m *LookUpPKVerifyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LookUpPKVerifyResponse.Marshal(b, m, deterministic)
}
func (m *LookUpPKVerifyResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LookUpPKVerifyResponse.Merge(m, src)
}
func (m *LookUpPKVerifyResponse) XXX_Size() int {
	return xxx_messageInfo_LookUpPKVerifyResponse.Size(m)
}
func (m *LookUpPKVerifyResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_LookUpPKVerifyResponse.DiscardUnknown(m)
}

var xxx_messageInfo_LookUpPKVerifyResponse proto.InternalMessageInfo

func (m *LookUpPKVerifyResponse) GetIek() *IndexedEK {
	if m != nil {
		return m.Iek
	}
	return nil
}

func (m *LookUpPKVerifyResponse) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *LookUpPKVerifyResponse) GetVrfKey() []byte {
	if m != nil {
		return m.VrfKey
	}
	return nil
}

func (m *LookUpPKVerifyResponse) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

type GetMasterKeyProofRequest struct {
	Usr                  *Username  `protobuf:"bytes,1,opt,name=usr,proto3" json:"usr,omitempty"`
	Key                  *MasterKey `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	Pos                  *Position  `protobuf:"bytes,3,opt,name=pos,proto3" json:"pos,omitempty"`
	Size                 uint64     `protobuf:"varint,4,opt,name=size,proto3" json:"size,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *GetMasterKeyProofRequest) Reset()         { *m = GetMasterKeyProofRequest{} }
func (m *GetMasterKeyProofRequest) String() string { return proto.CompactTextString(m) }
func (*GetMasterKeyProofRequest) ProtoMessage()    {}
func (*GetMasterKeyProofRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{30}
}

func (m *GetMasterKeyProofRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetMasterKeyProofRequest.Unmarshal(m, b)
}
func (m *GetMasterKeyProofRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetMasterKeyProofRequest.Marshal(b, m, deterministic)
}
func (m *GetMasterKeyProofRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetMasterKeyProofRequest.Merge(m, src)
}
func (m *GetMasterKeyProofRequest) XXX_Size() int {
	return xxx_messageInfo_GetMasterKeyProofRequest.Size(m)
}
func (m *GetMasterKeyProofRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetMasterKeyProofRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetMasterKeyProofRequest proto.InternalMessageInfo

func (m *GetMasterKeyProofRequest) GetUsr() *Username {
	if m != nil {
		return m.Usr
	}
	return nil
}

func (m *GetMasterKeyProofRequest) GetKey() *MasterKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *GetMasterKeyProofRequest) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

func (m *GetMasterKeyProofRequest) GetSize() uint64 {
	if m != nil {
		return m.Size
	}
	return 0
}

type GetMasterKeyProofResponse struct {
	Proof                []byte   `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetMasterKeyProofResponse) Reset()         { *m = GetMasterKeyProofResponse{} }
func (m *GetMasterKeyProofResponse) String() string { return proto.CompactTextString(m) }
func (*GetMasterKeyProofResponse) ProtoMessage()    {}
func (*GetMasterKeyProofResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{31}
}

func (m *GetMasterKeyProofResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetMasterKeyProofResponse.Unmarshal(m, b)
}
func (m *GetMasterKeyProofResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetMasterKeyProofResponse.Marshal(b, m, deterministic)
}
func (m *GetMasterKeyProofResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetMasterKeyProofResponse.Merge(m, src)
}
func (m *GetMasterKeyProofResponse) XXX_Size() int {
	return xxx_messageInfo_GetMasterKeyProofResponse.Size(m)
}
func (m *GetMasterKeyProofResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetMasterKeyProofResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetMasterKeyProofResponse proto.InternalMessageInfo

func (m *GetMasterKeyProofResponse) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

type GetPublicKeyProofRequest struct {
	Usr                  *Username      `protobuf:"bytes,1,opt,name=usr,proto3" json:"usr,omitempty"`
	Key                  *EncryptionKey `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	Pos                  *Position      `protobuf:"bytes,3,opt,name=pos,proto3" json:"pos,omitempty"`
	Height               uint32         `protobuf:"varint,4,opt,name=height,proto3" json:"height,omitempty"`
	Size                 uint64         `protobuf:"varint,5,opt,name=size,proto3" json:"size,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *GetPublicKeyProofRequest) Reset()         { *m = GetPublicKeyProofRequest{} }
func (m *GetPublicKeyProofRequest) String() string { return proto.CompactTextString(m) }
func (*GetPublicKeyProofRequest) ProtoMessage()    {}
func (*GetPublicKeyProofRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{32}
}

func (m *GetPublicKeyProofRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetPublicKeyProofRequest.Unmarshal(m, b)
}
func (m *GetPublicKeyProofRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetPublicKeyProofRequest.Marshal(b, m, deterministic)
}
func (m *GetPublicKeyProofRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetPublicKeyProofRequest.Merge(m, src)
}
func (m *GetPublicKeyProofRequest) XXX_Size() int {
	return xxx_messageInfo_GetPublicKeyProofRequest.Size(m)
}
func (m *GetPublicKeyProofRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetPublicKeyProofRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetPublicKeyProofRequest proto.InternalMessageInfo

func (m *GetPublicKeyProofRequest) GetUsr() *Username {
	if m != nil {
		return m.Usr
	}
	return nil
}

func (m *GetPublicKeyProofRequest) GetKey() *EncryptionKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *GetPublicKeyProofRequest) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

func (m *GetPublicKeyProofRequest) GetHeight() uint32 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *GetPublicKeyProofRequest) GetSize() uint64 {
	if m != nil {
		return m.Size
	}
	return 0
}

type GetPublicKeyProofResponse struct {
	Proof                []byte   `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetPublicKeyProofResponse) Reset()         { *m = GetPublicKeyProofResponse{} }
func (m *GetPublicKeyProofResponse) String() string { return proto.CompactTextString(m) }
func (*GetPublicKeyProofResponse) ProtoMessage()    {}
func (*GetPublicKeyProofResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{33}
}

func (m *GetPublicKeyProofResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetPublicKeyProofResponse.Unmarshal(m, b)
}
func (m *GetPublicKeyProofResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetPublicKeyProofResponse.Marshal(b, m, deterministic)
}
func (m *GetPublicKeyProofResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetPublicKeyProofResponse.Merge(m, src)
}
func (m *GetPublicKeyProofResponse) XXX_Size() int {
	return xxx_messageInfo_GetPublicKeyProofResponse.Size(m)
}
func (m *GetPublicKeyProofResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetPublicKeyProofResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetPublicKeyProofResponse proto.InternalMessageInfo

func (m *GetPublicKeyProofResponse) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

type GetLookUpProofRequest struct {
	IsMasterKey          bool           `protobuf:"varint,1,opt,name=is_master_key,json=isMasterKey,proto3" json:"is_master_key,omitempty"`
	Usr                  *Username      `protobuf:"bytes,2,opt,name=usr,proto3" json:"usr,omitempty"`
	MasterKey            *MasterKey     `protobuf:"bytes,3,opt,name=master_key,json=masterKey,proto3" json:"master_key,omitempty"`
	EncryptionKey        *EncryptionKey `protobuf:"bytes,4,opt,name=encryption_key,json=encryptionKey,proto3" json:"encryption_key,omitempty"`
	Pos                  *Position      `protobuf:"bytes,5,opt,name=pos,proto3" json:"pos,omitempty"`
	Size                 uint64         `protobuf:"varint,6,opt,name=size,proto3" json:"size,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *GetLookUpProofRequest) Reset()         { *m = GetLookUpProofRequest{} }
func (m *GetLookUpProofRequest) String() string { return proto.CompactTextString(m) }
func (*GetLookUpProofRequest) ProtoMessage()    {}
func (*GetLookUpProofRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{34}
}

func (m *GetLookUpProofRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetLookUpProofRequest.Unmarshal(m, b)
}
func (m *GetLookUpProofRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetLookUpProofRequest.Marshal(b, m, deterministic)
}
func (m *GetLookUpProofRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetLookUpProofRequest.Merge(m, src)
}
func (m *GetLookUpProofRequest) XXX_Size() int {
	return xxx_messageInfo_GetLookUpProofRequest.Size(m)
}
func (m *GetLookUpProofRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetLookUpProofRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetLookUpProofRequest proto.InternalMessageInfo

func (m *GetLookUpProofRequest) GetIsMasterKey() bool {
	if m != nil {
		return m.IsMasterKey
	}
	return false
}

func (m *GetLookUpProofRequest) GetUsr() *Username {
	if m != nil {
		return m.Usr
	}
	return nil
}

func (m *GetLookUpProofRequest) GetMasterKey() *MasterKey {
	if m != nil {
		return m.MasterKey
	}
	return nil
}

func (m *GetLookUpProofRequest) GetEncryptionKey() *EncryptionKey {
	if m != nil {
		return m.EncryptionKey
	}
	return nil
}

func (m *GetLookUpProofRequest) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

func (m *GetLookUpProofRequest) GetSize() uint64 {
	if m != nil {
		return m.Size
	}
	return 0
}

type GetLookUpProofResponse struct {
	Proof                []byte   `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetLookUpProofResponse) Reset()         { *m = GetLookUpProofResponse{} }
func (m *GetLookUpProofResponse) String() string { return proto.CompactTextString(m) }
func (*GetLookUpProofResponse) ProtoMessage()    {}
func (*GetLookUpProofResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{35}
}

func (m *GetLookUpProofResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetLookUpProofResponse.Unmarshal(m, b)
}
func (m *GetLookUpProofResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetLookUpProofResponse.Marshal(b, m, deterministic)
}
func (m *GetLookUpProofResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetLookUpProofResponse.Merge(m, src)
}
func (m *GetLookUpProofResponse) XXX_Size() int {
	return xxx_messageInfo_GetLookUpProofResponse.Size(m)
}
func (m *GetLookUpProofResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetLookUpProofResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetLookUpProofResponse proto.InternalMessageInfo

func (m *GetLookUpProofResponse) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

type VerifyRegisterRequest struct {
	Usr                  *Username  `protobuf:"bytes,1,opt,name=usr,proto3" json:"usr,omitempty"`
	VrfKey               []byte     `protobuf:"bytes,2,opt,name=vrf_key,json=vrfKey,proto3" json:"vrf_key,omitempty"`
	Key                  *MasterKey `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
	Signature            []byte     `protobuf:"bytes,4,opt,name=signature,proto3" json:"signature,omitempty"`
	Pos                  *Position  `protobuf:"bytes,5,opt,name=pos,proto3" json:"pos,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *VerifyRegisterRequest) Reset()         { *m = VerifyRegisterRequest{} }
func (m *VerifyRegisterRequest) String() string { return proto.CompactTextString(m) }
func (*VerifyRegisterRequest) ProtoMessage()    {}
func (*VerifyRegisterRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{36}
}

func (m *VerifyRegisterRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VerifyRegisterRequest.Unmarshal(m, b)
}
func (m *VerifyRegisterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VerifyRegisterRequest.Marshal(b, m, deterministic)
}
func (m *VerifyRegisterRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VerifyRegisterRequest.Merge(m, src)
}
func (m *VerifyRegisterRequest) XXX_Size() int {
	return xxx_messageInfo_VerifyRegisterRequest.Size(m)
}
func (m *VerifyRegisterRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_VerifyRegisterRequest.DiscardUnknown(m)
}

var xxx_messageInfo_VerifyRegisterRequest proto.InternalMessageInfo

func (m *VerifyRegisterRequest) GetUsr() *Username {
	if m != nil {
		return m.Usr
	}
	return nil
}

func (m *VerifyRegisterRequest) GetVrfKey() []byte {
	if m != nil {
		return m.VrfKey
	}
	return nil
}

func (m *VerifyRegisterRequest) GetKey() *MasterKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *VerifyRegisterRequest) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *VerifyRegisterRequest) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

type VerifyRegisterResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VerifyRegisterResponse) Reset()         { *m = VerifyRegisterResponse{} }
func (m *VerifyRegisterResponse) String() string { return proto.CompactTextString(m) }
func (*VerifyRegisterResponse) ProtoMessage()    {}
func (*VerifyRegisterResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{37}
}

func (m *VerifyRegisterResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VerifyRegisterResponse.Unmarshal(m, b)
}
func (m *VerifyRegisterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VerifyRegisterResponse.Marshal(b, m, deterministic)
}
func (m *VerifyRegisterResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VerifyRegisterResponse.Merge(m, src)
}
func (m *VerifyRegisterResponse) XXX_Size() int {
	return xxx_messageInfo_VerifyRegisterResponse.Size(m)
}
func (m *VerifyRegisterResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_VerifyRegisterResponse.DiscardUnknown(m)
}

var xxx_messageInfo_VerifyRegisterResponse proto.InternalMessageInfo

type VerifyAppendRequest struct {
	Usr                  *Username      `protobuf:"bytes,1,opt,name=usr,proto3" json:"usr,omitempty"`
	VrfKey               []byte         `protobuf:"bytes,2,opt,name=vrf_key,json=vrfKey,proto3" json:"vrf_key,omitempty"`
	Key                  *EncryptionKey `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
	Signature            []byte         `protobuf:"bytes,4,opt,name=signature,proto3" json:"signature,omitempty"`
	Pos                  *Position      `protobuf:"bytes,5,opt,name=pos,proto3" json:"pos,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *VerifyAppendRequest) Reset()         { *m = VerifyAppendRequest{} }
func (m *VerifyAppendRequest) String() string { return proto.CompactTextString(m) }
func (*VerifyAppendRequest) ProtoMessage()    {}
func (*VerifyAppendRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{38}
}

func (m *VerifyAppendRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VerifyAppendRequest.Unmarshal(m, b)
}
func (m *VerifyAppendRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VerifyAppendRequest.Marshal(b, m, deterministic)
}
func (m *VerifyAppendRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VerifyAppendRequest.Merge(m, src)
}
func (m *VerifyAppendRequest) XXX_Size() int {
	return xxx_messageInfo_VerifyAppendRequest.Size(m)
}
func (m *VerifyAppendRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_VerifyAppendRequest.DiscardUnknown(m)
}

var xxx_messageInfo_VerifyAppendRequest proto.InternalMessageInfo

func (m *VerifyAppendRequest) GetUsr() *Username {
	if m != nil {
		return m.Usr
	}
	return nil
}

func (m *VerifyAppendRequest) GetVrfKey() []byte {
	if m != nil {
		return m.VrfKey
	}
	return nil
}

func (m *VerifyAppendRequest) GetKey() *EncryptionKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *VerifyAppendRequest) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *VerifyAppendRequest) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

type VerifyAppendResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VerifyAppendResponse) Reset()         { *m = VerifyAppendResponse{} }
func (m *VerifyAppendResponse) String() string { return proto.CompactTextString(m) }
func (*VerifyAppendResponse) ProtoMessage()    {}
func (*VerifyAppendResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{39}
}

func (m *VerifyAppendResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VerifyAppendResponse.Unmarshal(m, b)
}
func (m *VerifyAppendResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VerifyAppendResponse.Marshal(b, m, deterministic)
}
func (m *VerifyAppendResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VerifyAppendResponse.Merge(m, src)
}
func (m *VerifyAppendResponse) XXX_Size() int {
	return xxx_messageInfo_VerifyAppendResponse.Size(m)
}
func (m *VerifyAppendResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_VerifyAppendResponse.DiscardUnknown(m)
}

var xxx_messageInfo_VerifyAppendResponse proto.InternalMessageInfo

type VerifyLookUpRequest struct {
	IsMasterKey          bool           `protobuf:"varint,1,opt,name=is_master_key,json=isMasterKey,proto3" json:"is_master_key,omitempty"`
	Usr                  *Username      `protobuf:"bytes,2,opt,name=usr,proto3" json:"usr,omitempty"`
	Vrf                  []byte         `protobuf:"bytes,3,opt,name=vrf,proto3" json:"vrf,omitempty"`
	MasterKey            *MasterKey     `protobuf:"bytes,4,opt,name=master_key,json=masterKey,proto3" json:"master_key,omitempty"`
	EncryptionKey        *EncryptionKey `protobuf:"bytes,5,opt,name=encryption_key,json=encryptionKey,proto3" json:"encryption_key,omitempty"`
	Signature            []byte         `protobuf:"bytes,6,opt,name=signature,proto3" json:"signature,omitempty"`
	Pos                  *Position      `protobuf:"bytes,7,opt,name=pos,proto3" json:"pos,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *VerifyLookUpRequest) Reset()         { *m = VerifyLookUpRequest{} }
func (m *VerifyLookUpRequest) String() string { return proto.CompactTextString(m) }
func (*VerifyLookUpRequest) ProtoMessage()    {}
func (*VerifyLookUpRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{40}
}

func (m *VerifyLookUpRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VerifyLookUpRequest.Unmarshal(m, b)
}
func (m *VerifyLookUpRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VerifyLookUpRequest.Marshal(b, m, deterministic)
}
func (m *VerifyLookUpRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VerifyLookUpRequest.Merge(m, src)
}
func (m *VerifyLookUpRequest) XXX_Size() int {
	return xxx_messageInfo_VerifyLookUpRequest.Size(m)
}
func (m *VerifyLookUpRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_VerifyLookUpRequest.DiscardUnknown(m)
}

var xxx_messageInfo_VerifyLookUpRequest proto.InternalMessageInfo

func (m *VerifyLookUpRequest) GetIsMasterKey() bool {
	if m != nil {
		return m.IsMasterKey
	}
	return false
}

func (m *VerifyLookUpRequest) GetUsr() *Username {
	if m != nil {
		return m.Usr
	}
	return nil
}

func (m *VerifyLookUpRequest) GetVrf() []byte {
	if m != nil {
		return m.Vrf
	}
	return nil
}

func (m *VerifyLookUpRequest) GetMasterKey() *MasterKey {
	if m != nil {
		return m.MasterKey
	}
	return nil
}

func (m *VerifyLookUpRequest) GetEncryptionKey() *EncryptionKey {
	if m != nil {
		return m.EncryptionKey
	}
	return nil
}

func (m *VerifyLookUpRequest) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *VerifyLookUpRequest) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

type VerifyLookUpResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VerifyLookUpResponse) Reset()         { *m = VerifyLookUpResponse{} }
func (m *VerifyLookUpResponse) String() string { return proto.CompactTextString(m) }
func (*VerifyLookUpResponse) ProtoMessage()    {}
func (*VerifyLookUpResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{41}
}

func (m *VerifyLookUpResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VerifyLookUpResponse.Unmarshal(m, b)
}
func (m *VerifyLookUpResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VerifyLookUpResponse.Marshal(b, m, deterministic)
}
func (m *VerifyLookUpResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VerifyLookUpResponse.Merge(m, src)
}
func (m *VerifyLookUpResponse) XXX_Size() int {
	return xxx_messageInfo_VerifyLookUpResponse.Size(m)
}
func (m *VerifyLookUpResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_VerifyLookUpResponse.DiscardUnknown(m)
}

var xxx_messageInfo_VerifyLookUpResponse proto.InternalMessageInfo

type GetNewCheckPointRequest struct {
	OldSize              uint64   `protobuf:"varint,1,opt,name=old_size,json=oldSize,proto3" json:"old_size,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetNewCheckPointRequest) Reset()         { *m = GetNewCheckPointRequest{} }
func (m *GetNewCheckPointRequest) String() string { return proto.CompactTextString(m) }
func (*GetNewCheckPointRequest) ProtoMessage()    {}
func (*GetNewCheckPointRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{42}
}

func (m *GetNewCheckPointRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetNewCheckPointRequest.Unmarshal(m, b)
}
func (m *GetNewCheckPointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetNewCheckPointRequest.Marshal(b, m, deterministic)
}
func (m *GetNewCheckPointRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetNewCheckPointRequest.Merge(m, src)
}
func (m *GetNewCheckPointRequest) XXX_Size() int {
	return xxx_messageInfo_GetNewCheckPointRequest.Size(m)
}
func (m *GetNewCheckPointRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetNewCheckPointRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetNewCheckPointRequest proto.InternalMessageInfo

func (m *GetNewCheckPointRequest) GetOldSize() uint64 {
	if m != nil {
		return m.OldSize
	}
	return 0
}

type GetNewCheckPointResponse struct {
	CkPoint              *CheckPoint `protobuf:"bytes,1,opt,name=ck_point,json=ckPoint,proto3" json:"ck_point,omitempty"`
	Proof                []byte      `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *GetNewCheckPointResponse) Reset()         { *m = GetNewCheckPointResponse{} }
func (m *GetNewCheckPointResponse) String() string { return proto.CompactTextString(m) }
func (*GetNewCheckPointResponse) ProtoMessage()    {}
func (*GetNewCheckPointResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{43}
}

func (m *GetNewCheckPointResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetNewCheckPointResponse.Unmarshal(m, b)
}
func (m *GetNewCheckPointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetNewCheckPointResponse.Marshal(b, m, deterministic)
}
func (m *GetNewCheckPointResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetNewCheckPointResponse.Merge(m, src)
}
func (m *GetNewCheckPointResponse) XXX_Size() int {
	return xxx_messageInfo_GetNewCheckPointResponse.Size(m)
}
func (m *GetNewCheckPointResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetNewCheckPointResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetNewCheckPointResponse proto.InternalMessageInfo

func (m *GetNewCheckPointResponse) GetCkPoint() *CheckPoint {
	if m != nil {
		return m.CkPoint
	}
	return nil
}

func (m *GetNewCheckPointResponse) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

type GetEpochUpdateRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetEpochUpdateRequest) Reset()         { *m = GetEpochUpdateRequest{} }
func (m *GetEpochUpdateRequest) String() string { return proto.CompactTextString(m) }
func (*GetEpochUpdateRequest) ProtoMessage()    {}
func (*GetEpochUpdateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{44}
}

func (m *GetEpochUpdateRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetEpochUpdateRequest.Unmarshal(m, b)
}
func (m *GetEpochUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetEpochUpdateRequest.Marshal(b, m, deterministic)
}
func (m *GetEpochUpdateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetEpochUpdateRequest.Merge(m, src)
}
func (m *GetEpochUpdateRequest) XXX_Size() int {
	return xxx_messageInfo_GetEpochUpdateRequest.Size(m)
}
func (m *GetEpochUpdateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetEpochUpdateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetEpochUpdateRequest proto.InternalMessageInfo

type GetEpochUpdateResponse struct {
	CkPoint              *CheckPoint `protobuf:"bytes,1,opt,name=ck_point,json=ckPoint,proto3" json:"ck_point,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *GetEpochUpdateResponse) Reset()         { *m = GetEpochUpdateResponse{} }
func (m *GetEpochUpdateResponse) String() string { return proto.CompactTextString(m) }
func (*GetEpochUpdateResponse) ProtoMessage()    {}
func (*GetEpochUpdateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3ef53c9e620778f1, []int{45}
}

func (m *GetEpochUpdateResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetEpochUpdateResponse.Unmarshal(m, b)
}
func (m *GetEpochUpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetEpochUpdateResponse.Marshal(b, m, deterministic)
}
func (m *GetEpochUpdateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetEpochUpdateResponse.Merge(m, src)
}
func (m *GetEpochUpdateResponse) XXX_Size() int {
	return xxx_messageInfo_GetEpochUpdateResponse.Size(m)
}
func (m *GetEpochUpdateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetEpochUpdateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetEpochUpdateResponse proto.InternalMessageInfo

func (m *GetEpochUpdateResponse) GetCkPoint() *CheckPoint {
	if m != nil {
		return m.CkPoint
	}
	return nil
}

func init() {
	proto.RegisterEnum("grpcint.MerkleProof_MerkleProofType", MerkleProof_MerkleProofType_name, MerkleProof_MerkleProofType_value)
	proto.RegisterType((*EncryptionKey)(nil), "grpcint.EncryptionKey")
	proto.RegisterType((*MasterKey)(nil), "grpcint.MasterKey")
	proto.RegisterType((*Hash)(nil), "grpcint.Hash")
	proto.RegisterType((*Username)(nil), "grpcint.Username")
	proto.RegisterType((*OrganizationName)(nil), "grpcint.OrganizationName")
	proto.RegisterType((*Position)(nil), "grpcint.Position")
	proto.RegisterType((*IndexedEK)(nil), "grpcint.IndexedEK")
	proto.RegisterType((*IndexedMK)(nil), "grpcint.IndexedMK")
	proto.RegisterType((*MerklePath)(nil), "grpcint.MerklePath")
	proto.RegisterType((*MerkleProof)(nil), "grpcint.MerkleProof")
	proto.RegisterType((*RegisterProof)(nil), "grpcint.RegisterProof")
	proto.RegisterType((*LookUpProof)(nil), "grpcint.LookUpProof")
	proto.RegisterType((*AppendProof)(nil), "grpcint.AppendProof")
	proto.RegisterType((*RootHash)(nil), "grpcint.RootHash")
	proto.RegisterType((*CheckPoint)(nil), "grpcint.CheckPoint")
	proto.RegisterType((*ExtensionProof)(nil), "grpcint.ExtensionProof")
	proto.RegisterType((*GetMonitoringProofForTestRequest)(nil), "grpcint.GetMonitoringProofForTestRequest")
	proto.RegisterType((*GetMonitoringProofForTestResponse)(nil), "grpcint.GetMonitoringProofForTestResponse")
	proto.RegisterType((*RegisterRequest)(nil), "grpcint.RegisterRequest")
	proto.RegisterType((*RegisterResponse)(nil), "grpcint.RegisterResponse")
	proto.RegisterType((*AppendRequest)(nil), "grpcint.AppendRequest")
	proto.RegisterType((*AppendResponse)(nil), "grpcint.AppendResponse")
	proto.RegisterType((*LookUpMKRequest)(nil), "grpcint.LookUpMKRequest")
	proto.RegisterType((*LookUpMKResponse)(nil), "grpcint.LookUpMKResponse")
	proto.RegisterType((*LookUpMKVerifyRequest)(nil), "grpcint.LookUpMKVerifyRequest")
	proto.RegisterType((*LookUpMKVerifyResponse)(nil), "grpcint.LookUpMKVerifyResponse")
	proto.RegisterType((*LookUpPKRequest)(nil), "grpcint.LookUpPKRequest")
	proto.RegisterType((*LookUpPKResponse)(nil), "grpcint.LookUpPKResponse")
	proto.RegisterType((*LookUpPKVerifyRequest)(nil), "grpcint.LookUpPKVerifyRequest")
	proto.RegisterType((*LookUpPKVerifyResponse)(nil), "grpcint.LookUpPKVerifyResponse")
	proto.RegisterType((*GetMasterKeyProofRequest)(nil), "grpcint.GetMasterKeyProofRequest")
	proto.RegisterType((*GetMasterKeyProofResponse)(nil), "grpcint.GetMasterKeyProofResponse")
	proto.RegisterType((*GetPublicKeyProofRequest)(nil), "grpcint.GetPublicKeyProofRequest")
	proto.RegisterType((*GetPublicKeyProofResponse)(nil), "grpcint.GetPublicKeyProofResponse")
	proto.RegisterType((*GetLookUpProofRequest)(nil), "grpcint.GetLookUpProofRequest")
	proto.RegisterType((*GetLookUpProofResponse)(nil), "grpcint.GetLookUpProofResponse")
	proto.RegisterType((*VerifyRegisterRequest)(nil), "grpcint.VerifyRegisterRequest")
	proto.RegisterType((*VerifyRegisterResponse)(nil), "grpcint.VerifyRegisterResponse")
	proto.RegisterType((*VerifyAppendRequest)(nil), "grpcint.VerifyAppendRequest")
	proto.RegisterType((*VerifyAppendResponse)(nil), "grpcint.VerifyAppendResponse")
	proto.RegisterType((*VerifyLookUpRequest)(nil), "grpcint.VerifyLookUpRequest")
	proto.RegisterType((*VerifyLookUpResponse)(nil), "grpcint.VerifyLookUpResponse")
	proto.RegisterType((*GetNewCheckPointRequest)(nil), "grpcint.GetNewCheckPointRequest")
	proto.RegisterType((*GetNewCheckPointResponse)(nil), "grpcint.GetNewCheckPointResponse")
	proto.RegisterType((*GetEpochUpdateRequest)(nil), "grpcint.GetEpochUpdateRequest")
	proto.RegisterType((*GetEpochUpdateResponse)(nil), "grpcint.GetEpochUpdateResponse")
}

func init() {
	proto.RegisterFile("interface.proto", fileDescriptor_3ef53c9e620778f1)
}

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

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

// 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.SupportPackageIsVersion6

// MerkleSquareClient is the client API for MerkleSquare service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MerkleSquareClient interface {
	// Client-Server API
	Register(ctx context.Context, in *RegisterRequest, opts ...grpc.CallOption) (*RegisterResponse, error)
	Append(ctx context.Context, opts ...grpc.CallOption) (MerkleSquare_AppendClient, error)
	LookUpMK(ctx context.Context, in *LookUpMKRequest, opts ...grpc.CallOption) (*LookUpMKResponse, error)
	LookUpPK(ctx context.Context, in *LookUpPKRequest, opts ...grpc.CallOption) (*LookUpPKResponse, error)
	LookUpMKVerify(ctx context.Context, in *LookUpMKVerifyRequest, opts ...grpc.CallOption) (*LookUpMKVerifyResponse, error)
	LookUpPKVerify(ctx context.Context, in *LookUpPKVerifyRequest, opts ...grpc.CallOption) (*LookUpPKVerifyResponse, error)
	GetMonitoringProofForTest(ctx context.Context, in *GetMonitoringProofForTestRequest, opts ...grpc.CallOption) (*GetMonitoringProofForTestResponse, error)
	// Verifier-Server API
	GetMasterKeyProof(ctx context.Context, in *GetMasterKeyProofRequest, opts ...grpc.CallOption) (*GetMasterKeyProofResponse, error)
	GetPublicKeyProof(ctx context.Context, in *GetPublicKeyProofRequest, opts ...grpc.CallOption) (*GetPublicKeyProofResponse, error)
	GetLookUpProof(ctx context.Context, in *GetLookUpProofRequest, opts ...grpc.CallOption) (*GetLookUpProofResponse, error)
	// Auditor Interface
	GetNewCheckPoint(ctx context.Context, in *GetNewCheckPointRequest, opts ...grpc.CallOption) (*GetNewCheckPointResponse, error)
}

type merkleSquareClient struct {
	cc grpc.ClientConnInterface
}

func NewMerkleSquareClient(cc grpc.ClientConnInterface) MerkleSquareClient {
	return &merkleSquareClient{cc}
}

func (c *merkleSquareClient) Register(ctx context.Context, in *RegisterRequest, opts ...grpc.CallOption) (*RegisterResponse, error) {
	out := new(RegisterResponse)
	err := c.cc.Invoke(ctx, "/grpcint.MerkleSquare/Register", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *merkleSquareClient) Append(ctx context.Context, opts ...grpc.CallOption) (MerkleSquare_AppendClient, error) {
	stream, err := c.cc.NewStream(ctx, &_MerkleSquare_serviceDesc.Streams[0], "/grpcint.MerkleSquare/Append", opts...)
	if err != nil {
		return nil, err
	}
	x := &merkleSquareAppendClient{stream}
	return x, nil
}

type MerkleSquare_AppendClient interface {
	Send(*AppendRequest) error
	Recv() (*AppendResponse, error)
	grpc.ClientStream
}

type merkleSquareAppendClient struct {
	grpc.ClientStream
}

func (x *merkleSquareAppendClient) Send(m *AppendRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *merkleSquareAppendClient) Recv() (*AppendResponse, error) {
	m := new(AppendResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *merkleSquareClient) LookUpMK(ctx context.Context, in *LookUpMKRequest, opts ...grpc.CallOption) (*LookUpMKResponse, error) {
	out := new(LookUpMKResponse)
	err := c.cc.Invoke(ctx, "/grpcint.MerkleSquare/LookUpMK", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *merkleSquareClient) LookUpPK(ctx context.Context, in *LookUpPKRequest, opts ...grpc.CallOption) (*LookUpPKResponse, error) {
	out := new(LookUpPKResponse)
	err := c.cc.Invoke(ctx, "/grpcint.MerkleSquare/LookUpPK", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *merkleSquareClient) LookUpMKVerify(ctx context.Context, in *LookUpMKVerifyRequest, opts ...grpc.CallOption) (*LookUpMKVerifyResponse, error) {
	out := new(LookUpMKVerifyResponse)
	err := c.cc.Invoke(ctx, "/grpcint.MerkleSquare/LookUpMKVerify", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *merkleSquareClient) LookUpPKVerify(ctx context.Context, in *LookUpPKVerifyRequest, opts ...grpc.CallOption) (*LookUpPKVerifyResponse, error) {
	out := new(LookUpPKVerifyResponse)
	err := c.cc.Invoke(ctx, "/grpcint.MerkleSquare/LookUpPKVerify", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *merkleSquareClient) GetMonitoringProofForTest(ctx context.Context, in *GetMonitoringProofForTestRequest, opts ...grpc.CallOption) (*GetMonitoringProofForTestResponse, error) {
	out := new(GetMonitoringProofForTestResponse)
	err := c.cc.Invoke(ctx, "/grpcint.MerkleSquare/GetMonitoringProofForTest", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *merkleSquareClient) GetMasterKeyProof(ctx context.Context, in *GetMasterKeyProofRequest, opts ...grpc.CallOption) (*GetMasterKeyProofResponse, error) {
	out := new(GetMasterKeyProofResponse)
	err := c.cc.Invoke(ctx, "/grpcint.MerkleSquare/GetMasterKeyProof", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *merkleSquareClient) GetPublicKeyProof(ctx context.Context, in *GetPublicKeyProofRequest, opts ...grpc.CallOption) (*GetPublicKeyProofResponse, error) {
	out := new(GetPublicKeyProofResponse)
	err := c.cc.Invoke(ctx, "/grpcint.MerkleSquare/GetPublicKeyProof", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *merkleSquareClient) GetLookUpProof(ctx context.Context, in *GetLookUpProofRequest, opts ...grpc.CallOption) (*GetLookUpProofResponse, error) {
	out := new(GetLookUpProofResponse)
	err := c.cc.Invoke(ctx, "/grpcint.MerkleSquare/GetLookUpProof", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *merkleSquareClient) GetNewCheckPoint(ctx context.Context, in *GetNewCheckPointRequest, opts ...grpc.CallOption) (*GetNewCheckPointResponse, error) {
	out := new(GetNewCheckPointResponse)
	err := c.cc.Invoke(ctx, "/grpcint.MerkleSquare/GetNewCheckPoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MerkleSquareServer is the server API for MerkleSquare service.
type MerkleSquareServer interface {
	// Client-Server API
	Register(context.Context, *RegisterRequest) (*RegisterResponse, error)
	Append(MerkleSquare_AppendServer) error
	LookUpMK(context.Context, *LookUpMKRequest) (*LookUpMKResponse, error)
	LookUpPK(context.Context, *LookUpPKRequest) (*LookUpPKResponse, error)
	LookUpMKVerify(context.Context, *LookUpMKVerifyRequest) (*LookUpMKVerifyResponse, error)
	LookUpPKVerify(context.Context, *LookUpPKVerifyRequest) (*LookUpPKVerifyResponse, error)
	GetMonitoringProofForTest(context.Context, *GetMonitoringProofForTestRequest) (*GetMonitoringProofForTestResponse, error)
	// Verifier-Server API
	GetMasterKeyProof(context.Context, *GetMasterKeyProofRequest) (*GetMasterKeyProofResponse, error)
	GetPublicKeyProof(context.Context, *GetPublicKeyProofRequest) (*GetPublicKeyProofResponse, error)
	GetLookUpProof(context.Context, *GetLookUpProofRequest) (*GetLookUpProofResponse, error)
	// Auditor Interface
	GetNewCheckPoint(context.Context, *GetNewCheckPointRequest) (*GetNewCheckPointResponse, error)
}

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

func (*UnimplementedMerkleSquareServer) Register(ctx context.Context, req *RegisterRequest) (*RegisterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Register not implemented")
}
func (*UnimplementedMerkleSquareServer) Append(srv MerkleSquare_AppendServer) error {
	return status.Errorf(codes.Unimplemented, "method Append not implemented")
}
func (*UnimplementedMerkleSquareServer) LookUpMK(ctx context.Context, req *LookUpMKRequest) (*LookUpMKResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LookUpMK not implemented")
}
func (*UnimplementedMerkleSquareServer) LookUpPK(ctx context.Context, req *LookUpPKRequest) (*LookUpPKResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LookUpPK not implemented")
}
func (*UnimplementedMerkleSquareServer) LookUpMKVerify(ctx context.Context, req *LookUpMKVerifyRequest) (*LookUpMKVerifyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LookUpMKVerify not implemented")
}
func (*UnimplementedMerkleSquareServer) LookUpPKVerify(ctx context.Context, req *LookUpPKVerifyRequest) (*LookUpPKVerifyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LookUpPKVerify not implemented")
}
func (*UnimplementedMerkleSquareServer) GetMonitoringProofForTest(ctx context.Context, req *GetMonitoringProofForTestRequest) (*GetMonitoringProofForTestResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMonitoringProofForTest not implemented")
}
func (*UnimplementedMerkleSquareServer) GetMasterKeyProof(ctx context.Context, req *GetMasterKeyProofRequest) (*GetMasterKeyProofResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMasterKeyProof not implemented")
}
func (*UnimplementedMerkleSquareServer) GetPublicKeyProof(ctx context.Context, req *GetPublicKeyProofRequest) (*GetPublicKeyProofResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPublicKeyProof not implemented")
}
func (*UnimplementedMerkleSquareServer) GetLookUpProof(ctx context.Context, req *GetLookUpProofRequest) (*GetLookUpProofResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLookUpProof not implemented")
}
func (*UnimplementedMerkleSquareServer) GetNewCheckPoint(ctx context.Context, req *GetNewCheckPointRequest) (*GetNewCheckPointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetNewCheckPoint not implemented")
}

func RegisterMerkleSquareServer(s *grpc.Server, srv MerkleSquareServer) {
	s.RegisterService(&_MerkleSquare_serviceDesc, srv)
}

func _MerkleSquare_Register_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegisterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MerkleSquareServer).Register(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcint.MerkleSquare/Register",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MerkleSquareServer).Register(ctx, req.(*RegisterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MerkleSquare_Append_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MerkleSquareServer).Append(&merkleSquareAppendServer{stream})
}

type MerkleSquare_AppendServer interface {
	Send(*AppendResponse) error
	Recv() (*AppendRequest, error)
	grpc.ServerStream
}

type merkleSquareAppendServer struct {
	grpc.ServerStream
}

func (x *merkleSquareAppendServer) Send(m *AppendResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *merkleSquareAppendServer) Recv() (*AppendRequest, error) {
	m := new(AppendRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _MerkleSquare_LookUpMK_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LookUpMKRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MerkleSquareServer).LookUpMK(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcint.MerkleSquare/LookUpMK",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MerkleSquareServer).LookUpMK(ctx, req.(*LookUpMKRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MerkleSquare_LookUpPK_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LookUpPKRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MerkleSquareServer).LookUpPK(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcint.MerkleSquare/LookUpPK",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MerkleSquareServer).LookUpPK(ctx, req.(*LookUpPKRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MerkleSquare_LookUpMKVerify_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LookUpMKVerifyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MerkleSquareServer).LookUpMKVerify(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcint.MerkleSquare/LookUpMKVerify",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MerkleSquareServer).LookUpMKVerify(ctx, req.(*LookUpMKVerifyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MerkleSquare_LookUpPKVerify_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LookUpPKVerifyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MerkleSquareServer).LookUpPKVerify(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcint.MerkleSquare/LookUpPKVerify",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MerkleSquareServer).LookUpPKVerify(ctx, req.(*LookUpPKVerifyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MerkleSquare_GetMonitoringProofForTest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetMonitoringProofForTestRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MerkleSquareServer).GetMonitoringProofForTest(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcint.MerkleSquare/GetMonitoringProofForTest",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MerkleSquareServer).GetMonitoringProofForTest(ctx, req.(*GetMonitoringProofForTestRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MerkleSquare_GetMasterKeyProof_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetMasterKeyProofRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MerkleSquareServer).GetMasterKeyProof(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcint.MerkleSquare/GetMasterKeyProof",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MerkleSquareServer).GetMasterKeyProof(ctx, req.(*GetMasterKeyProofRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MerkleSquare_GetPublicKeyProof_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPublicKeyProofRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MerkleSquareServer).GetPublicKeyProof(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcint.MerkleSquare/GetPublicKeyProof",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MerkleSquareServer).GetPublicKeyProof(ctx, req.(*GetPublicKeyProofRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MerkleSquare_GetLookUpProof_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLookUpProofRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MerkleSquareServer).GetLookUpProof(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcint.MerkleSquare/GetLookUpProof",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MerkleSquareServer).GetLookUpProof(ctx, req.(*GetLookUpProofRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MerkleSquare_GetNewCheckPoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetNewCheckPointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MerkleSquareServer).GetNewCheckPoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcint.MerkleSquare/GetNewCheckPoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MerkleSquareServer).GetNewCheckPoint(ctx, req.(*GetNewCheckPointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _MerkleSquare_serviceDesc = grpc.ServiceDesc{
	ServiceName: "grpcint.MerkleSquare",
	HandlerType: (*MerkleSquareServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Register",
			Handler:    _MerkleSquare_Register_Handler,
		},
		{
			MethodName: "LookUpMK",
			Handler:    _MerkleSquare_LookUpMK_Handler,
		},
		{
			MethodName: "LookUpPK",
			Handler:    _MerkleSquare_LookUpPK_Handler,
		},
		{
			MethodName: "LookUpMKVerify",
			Handler:    _MerkleSquare_LookUpMKVerify_Handler,
		},
		{
			MethodName: "LookUpPKVerify",
			Handler:    _MerkleSquare_LookUpPKVerify_Handler,
		},
		{
			MethodName: "GetMonitoringProofForTest",
			Handler:    _MerkleSquare_GetMonitoringProofForTest_Handler,
		},
		{
			MethodName: "GetMasterKeyProof",
			Handler:    _MerkleSquare_GetMasterKeyProof_Handler,
		},
		{
			MethodName: "GetPublicKeyProof",
			Handler:    _MerkleSquare_GetPublicKeyProof_Handler,
		},
		{
			MethodName: "GetLookUpProof",
			Handler:    _MerkleSquare_GetLookUpProof_Handler,
		},
		{
			MethodName: "GetNewCheckPoint",
			Handler:    _MerkleSquare_GetNewCheckPoint_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Append",
			Handler:       _MerkleSquare_Append_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "interface.proto",
}

// AuditorClient is the client API for Auditor service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AuditorClient interface {
	// Auditor-Client-Server API
	GetEpochUpdate(ctx context.Context, in *GetEpochUpdateRequest, opts ...grpc.CallOption) (*GetEpochUpdateResponse, error)
}

type auditorClient struct {
	cc grpc.ClientConnInterface
}

func NewAuditorClient(cc grpc.ClientConnInterface) AuditorClient {
	return &auditorClient{cc}
}

func (c *auditorClient) GetEpochUpdate(ctx context.Context, in *GetEpochUpdateRequest, opts ...grpc.CallOption) (*GetEpochUpdateResponse, error) {
	out := new(GetEpochUpdateResponse)
	err := c.cc.Invoke(ctx, "/grpcint.Auditor/GetEpochUpdate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AuditorServer is the server API for Auditor service.
type AuditorServer interface {
	// Auditor-Client-Server API
	GetEpochUpdate(context.Context, *GetEpochUpdateRequest) (*GetEpochUpdateResponse, error)
}

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

func (*UnimplementedAuditorServer) GetEpochUpdate(ctx context.Context, req *GetEpochUpdateRequest) (*GetEpochUpdateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetEpochUpdate not implemented")
}

func RegisterAuditorServer(s *grpc.Server, srv AuditorServer) {
	s.RegisterService(&_Auditor_serviceDesc, srv)
}

func _Auditor_GetEpochUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetEpochUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AuditorServer).GetEpochUpdate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcint.Auditor/GetEpochUpdate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AuditorServer).GetEpochUpdate(ctx, req.(*GetEpochUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Auditor_serviceDesc = grpc.ServiceDesc{
	ServiceName: "grpcint.Auditor",
	HandlerType: (*AuditorServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetEpochUpdate",
			Handler:    _Auditor_GetEpochUpdate_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "interface.proto",
}

// VerifierClient is the client API for Verifier service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type VerifierClient interface {
	VerifyRegisterAsync(ctx context.Context, in *VerifyRegisterRequest, opts ...grpc.CallOption) (*VerifyRegisterResponse, error)
	VerifyAppendAsync(ctx context.Context, in *VerifyAppendRequest, opts ...grpc.CallOption) (*VerifyAppendResponse, error)
	VerifyLookUpAsync(ctx context.Context, in *VerifyLookUpRequest, opts ...grpc.CallOption) (*VerifyLookUpResponse, error)
}

type verifierClient struct {
	cc grpc.ClientConnInterface
}

func NewVerifierClient(cc grpc.ClientConnInterface) VerifierClient {
	return &verifierClient{cc}
}

func (c *verifierClient) VerifyRegisterAsync(ctx context.Context, in *VerifyRegisterRequest, opts ...grpc.CallOption) (*VerifyRegisterResponse, error) {
	out := new(VerifyRegisterResponse)
	err := c.cc.Invoke(ctx, "/grpcint.Verifier/VerifyRegisterAsync", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *verifierClient) VerifyAppendAsync(ctx context.Context, in *VerifyAppendRequest, opts ...grpc.CallOption) (*VerifyAppendResponse, error) {
	out := new(VerifyAppendResponse)
	err := c.cc.Invoke(ctx, "/grpcint.Verifier/VerifyAppendAsync", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *verifierClient) VerifyLookUpAsync(ctx context.Context, in *VerifyLookUpRequest, opts ...grpc.CallOption) (*VerifyLookUpResponse, error) {
	out := new(VerifyLookUpResponse)
	err := c.cc.Invoke(ctx, "/grpcint.Verifier/VerifyLookUpAsync", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// VerifierServer is the server API for Verifier service.
type VerifierServer interface {
	VerifyRegisterAsync(context.Context, *VerifyRegisterRequest) (*VerifyRegisterResponse, error)
	VerifyAppendAsync(context.Context, *VerifyAppendRequest) (*VerifyAppendResponse, error)
	VerifyLookUpAsync(context.Context, *VerifyLookUpRequest) (*VerifyLookUpResponse, error)
}

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

func (*UnimplementedVerifierServer) VerifyRegisterAsync(ctx context.Context, req *VerifyRegisterRequest) (*VerifyRegisterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VerifyRegisterAsync not implemented")
}
func (*UnimplementedVerifierServer) VerifyAppendAsync(ctx context.Context, req *VerifyAppendRequest) (*VerifyAppendResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VerifyAppendAsync not implemented")
}
func (*UnimplementedVerifierServer) VerifyLookUpAsync(ctx context.Context, req *VerifyLookUpRequest) (*VerifyLookUpResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VerifyLookUpAsync not implemented")
}

func RegisterVerifierServer(s *grpc.Server, srv VerifierServer) {
	s.RegisterService(&_Verifier_serviceDesc, srv)
}

func _Verifier_VerifyRegisterAsync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyRegisterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VerifierServer).VerifyRegisterAsync(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcint.Verifier/VerifyRegisterAsync",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VerifierServer).VerifyRegisterAsync(ctx, req.(*VerifyRegisterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Verifier_VerifyAppendAsync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyAppendRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VerifierServer).VerifyAppendAsync(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcint.Verifier/VerifyAppendAsync",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VerifierServer).VerifyAppendAsync(ctx, req.(*VerifyAppendRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Verifier_VerifyLookUpAsync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyLookUpRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VerifierServer).VerifyLookUpAsync(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpcint.Verifier/VerifyLookUpAsync",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VerifierServer).VerifyLookUpAsync(ctx, req.(*VerifyLookUpRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Verifier_serviceDesc = grpc.ServiceDesc{
	ServiceName: "grpcint.Verifier",
	HandlerType: (*VerifierServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "VerifyRegisterAsync",
			Handler:    _Verifier_VerifyRegisterAsync_Handler,
		},
		{
			MethodName: "VerifyAppendAsync",
			Handler:    _Verifier_VerifyAppendAsync_Handler,
		},
		{
			MethodName: "VerifyLookUpAsync",
			Handler:    _Verifier_VerifyLookUpAsync_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "interface.proto",
}