// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        (unknown)
// source: sync/sync.proto

package sync

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type GetChangeProofRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	StartRootHash []byte                 `protobuf:"bytes,1,opt,name=start_root_hash,json=startRootHash,proto3" json:"start_root_hash,omitempty"`
	EndRootHash   []byte                 `protobuf:"bytes,2,opt,name=end_root_hash,json=endRootHash,proto3" json:"end_root_hash,omitempty"`
	StartKey      *MaybeBytes            `protobuf:"bytes,3,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"`
	EndKey        *MaybeBytes            `protobuf:"bytes,4,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"`
	KeyLimit      uint32                 `protobuf:"varint,5,opt,name=key_limit,json=keyLimit,proto3" json:"key_limit,omitempty"`
	BytesLimit    uint32                 `protobuf:"varint,6,opt,name=bytes_limit,json=bytesLimit,proto3" json:"bytes_limit,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetChangeProofRequest) Reset() {
	*x = GetChangeProofRequest{}
	mi := &file_sync_sync_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetChangeProofRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetChangeProofRequest) ProtoMessage() {}

func (x *GetChangeProofRequest) ProtoReflect() protoreflect.Message {
	mi := &file_sync_sync_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetChangeProofRequest.ProtoReflect.Descriptor instead.
func (*GetChangeProofRequest) Descriptor() ([]byte, []int) {
	return file_sync_sync_proto_rawDescGZIP(), []int{0}
}

func (x *GetChangeProofRequest) GetStartRootHash() []byte {
	if x != nil {
		return x.StartRootHash
	}
	return nil
}

func (x *GetChangeProofRequest) GetEndRootHash() []byte {
	if x != nil {
		return x.EndRootHash
	}
	return nil
}

func (x *GetChangeProofRequest) GetStartKey() *MaybeBytes {
	if x != nil {
		return x.StartKey
	}
	return nil
}

func (x *GetChangeProofRequest) GetEndKey() *MaybeBytes {
	if x != nil {
		return x.EndKey
	}
	return nil
}

func (x *GetChangeProofRequest) GetKeyLimit() uint32 {
	if x != nil {
		return x.KeyLimit
	}
	return 0
}

func (x *GetChangeProofRequest) GetBytesLimit() uint32 {
	if x != nil {
		return x.BytesLimit
	}
	return 0
}

type GetChangeProofResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Response:
	//
	//	*GetChangeProofResponse_ChangeProof
	//	*GetChangeProofResponse_RangeProof
	Response      isGetChangeProofResponse_Response `protobuf_oneof:"response"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetChangeProofResponse) Reset() {
	*x = GetChangeProofResponse{}
	mi := &file_sync_sync_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetChangeProofResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetChangeProofResponse) ProtoMessage() {}

func (x *GetChangeProofResponse) ProtoReflect() protoreflect.Message {
	mi := &file_sync_sync_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetChangeProofResponse.ProtoReflect.Descriptor instead.
func (*GetChangeProofResponse) Descriptor() ([]byte, []int) {
	return file_sync_sync_proto_rawDescGZIP(), []int{1}
}

func (x *GetChangeProofResponse) GetResponse() isGetChangeProofResponse_Response {
	if x != nil {
		return x.Response
	}
	return nil
}

func (x *GetChangeProofResponse) GetChangeProof() []byte {
	if x != nil {
		if x, ok := x.Response.(*GetChangeProofResponse_ChangeProof); ok {
			return x.ChangeProof
		}
	}
	return nil
}

func (x *GetChangeProofResponse) GetRangeProof() []byte {
	if x != nil {
		if x, ok := x.Response.(*GetChangeProofResponse_RangeProof); ok {
			return x.RangeProof
		}
	}
	return nil
}

type isGetChangeProofResponse_Response interface {
	isGetChangeProofResponse_Response()
}

type GetChangeProofResponse_ChangeProof struct {
	ChangeProof []byte `protobuf:"bytes,1,opt,name=change_proof,json=changeProof,proto3,oneof"`
}

type GetChangeProofResponse_RangeProof struct {
	RangeProof []byte `protobuf:"bytes,2,opt,name=range_proof,json=rangeProof,proto3,oneof"`
}

func (*GetChangeProofResponse_ChangeProof) isGetChangeProofResponse_Response() {}

func (*GetChangeProofResponse_RangeProof) isGetChangeProofResponse_Response() {}

// Range proof responses don't require any extra data, so no message is needed.
type GetRangeProofRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	RootHash      []byte                 `protobuf:"bytes,1,opt,name=root_hash,json=rootHash,proto3" json:"root_hash,omitempty"`
	StartKey      *MaybeBytes            `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"`
	EndKey        *MaybeBytes            `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"`
	KeyLimit      uint32                 `protobuf:"varint,4,opt,name=key_limit,json=keyLimit,proto3" json:"key_limit,omitempty"`
	BytesLimit    uint32                 `protobuf:"varint,5,opt,name=bytes_limit,json=bytesLimit,proto3" json:"bytes_limit,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetRangeProofRequest) Reset() {
	*x = GetRangeProofRequest{}
	mi := &file_sync_sync_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetRangeProofRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetRangeProofRequest) ProtoMessage() {}

func (x *GetRangeProofRequest) ProtoReflect() protoreflect.Message {
	mi := &file_sync_sync_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetRangeProofRequest.ProtoReflect.Descriptor instead.
func (*GetRangeProofRequest) Descriptor() ([]byte, []int) {
	return file_sync_sync_proto_rawDescGZIP(), []int{2}
}

func (x *GetRangeProofRequest) GetRootHash() []byte {
	if x != nil {
		return x.RootHash
	}
	return nil
}

func (x *GetRangeProofRequest) GetStartKey() *MaybeBytes {
	if x != nil {
		return x.StartKey
	}
	return nil
}

func (x *GetRangeProofRequest) GetEndKey() *MaybeBytes {
	if x != nil {
		return x.EndKey
	}
	return nil
}

func (x *GetRangeProofRequest) GetKeyLimit() uint32 {
	if x != nil {
		return x.KeyLimit
	}
	return 0
}

func (x *GetRangeProofRequest) GetBytesLimit() uint32 {
	if x != nil {
		return x.BytesLimit
	}
	return 0
}

type ChangeProof struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	StartProof    []*ProofNode           `protobuf:"bytes,1,rep,name=start_proof,json=startProof,proto3" json:"start_proof,omitempty"`
	EndProof      []*ProofNode           `protobuf:"bytes,2,rep,name=end_proof,json=endProof,proto3" json:"end_proof,omitempty"`
	KeyChanges    []*KeyChange           `protobuf:"bytes,3,rep,name=key_changes,json=keyChanges,proto3" json:"key_changes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ChangeProof) Reset() {
	*x = ChangeProof{}
	mi := &file_sync_sync_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ChangeProof) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ChangeProof) ProtoMessage() {}

func (x *ChangeProof) ProtoReflect() protoreflect.Message {
	mi := &file_sync_sync_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ChangeProof.ProtoReflect.Descriptor instead.
func (*ChangeProof) Descriptor() ([]byte, []int) {
	return file_sync_sync_proto_rawDescGZIP(), []int{3}
}

func (x *ChangeProof) GetStartProof() []*ProofNode {
	if x != nil {
		return x.StartProof
	}
	return nil
}

func (x *ChangeProof) GetEndProof() []*ProofNode {
	if x != nil {
		return x.EndProof
	}
	return nil
}

func (x *ChangeProof) GetKeyChanges() []*KeyChange {
	if x != nil {
		return x.KeyChanges
	}
	return nil
}

type RangeProof struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	StartProof    []*ProofNode           `protobuf:"bytes,1,rep,name=start_proof,json=startProof,proto3" json:"start_proof,omitempty"`
	EndProof      []*ProofNode           `protobuf:"bytes,2,rep,name=end_proof,json=endProof,proto3" json:"end_proof,omitempty"`
	KeyValues     []*KeyValue            `protobuf:"bytes,3,rep,name=key_values,json=keyValues,proto3" json:"key_values,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RangeProof) Reset() {
	*x = RangeProof{}
	mi := &file_sync_sync_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RangeProof) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RangeProof) ProtoMessage() {}

func (x *RangeProof) ProtoReflect() protoreflect.Message {
	mi := &file_sync_sync_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RangeProof.ProtoReflect.Descriptor instead.
func (*RangeProof) Descriptor() ([]byte, []int) {
	return file_sync_sync_proto_rawDescGZIP(), []int{4}
}

func (x *RangeProof) GetStartProof() []*ProofNode {
	if x != nil {
		return x.StartProof
	}
	return nil
}

func (x *RangeProof) GetEndProof() []*ProofNode {
	if x != nil {
		return x.EndProof
	}
	return nil
}

func (x *RangeProof) GetKeyValues() []*KeyValue {
	if x != nil {
		return x.KeyValues
	}
	return nil
}

type ProofNode struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           *Key                   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	ValueOrHash   *MaybeBytes            `protobuf:"bytes,2,opt,name=value_or_hash,json=valueOrHash,proto3" json:"value_or_hash,omitempty"`
	Children      map[uint32][]byte      `protobuf:"bytes,3,rep,name=children,proto3" json:"children,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProofNode) Reset() {
	*x = ProofNode{}
	mi := &file_sync_sync_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ProofNode) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ProofNode) ProtoMessage() {}

func (x *ProofNode) ProtoReflect() protoreflect.Message {
	mi := &file_sync_sync_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ProofNode.ProtoReflect.Descriptor instead.
func (*ProofNode) Descriptor() ([]byte, []int) {
	return file_sync_sync_proto_rawDescGZIP(), []int{5}
}

func (x *ProofNode) GetKey() *Key {
	if x != nil {
		return x.Key
	}
	return nil
}

func (x *ProofNode) GetValueOrHash() *MaybeBytes {
	if x != nil {
		return x.ValueOrHash
	}
	return nil
}

func (x *ProofNode) GetChildren() map[uint32][]byte {
	if x != nil {
		return x.Children
	}
	return nil
}

type KeyChange struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           []byte                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value         *MaybeBytes            `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KeyChange) Reset() {
	*x = KeyChange{}
	mi := &file_sync_sync_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KeyChange) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KeyChange) ProtoMessage() {}

func (x *KeyChange) ProtoReflect() protoreflect.Message {
	mi := &file_sync_sync_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KeyChange.ProtoReflect.Descriptor instead.
func (*KeyChange) Descriptor() ([]byte, []int) {
	return file_sync_sync_proto_rawDescGZIP(), []int{6}
}

func (x *KeyChange) GetKey() []byte {
	if x != nil {
		return x.Key
	}
	return nil
}

func (x *KeyChange) GetValue() *MaybeBytes {
	if x != nil {
		return x.Value
	}
	return nil
}

type Key struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Length        uint64                 `protobuf:"varint,1,opt,name=length,proto3" json:"length,omitempty"`
	Value         []byte                 `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Key) Reset() {
	*x = Key{}
	mi := &file_sync_sync_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Key) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Key) ProtoMessage() {}

func (x *Key) ProtoReflect() protoreflect.Message {
	mi := &file_sync_sync_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Key.ProtoReflect.Descriptor instead.
func (*Key) Descriptor() ([]byte, []int) {
	return file_sync_sync_proto_rawDescGZIP(), []int{7}
}

func (x *Key) GetLength() uint64 {
	if x != nil {
		return x.Length
	}
	return 0
}

func (x *Key) GetValue() []byte {
	if x != nil {
		return x.Value
	}
	return nil
}

// If the message is present, the value is considered to be "something".
type MaybeBytes struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Value         []byte                 `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MaybeBytes) Reset() {
	*x = MaybeBytes{}
	mi := &file_sync_sync_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *MaybeBytes) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MaybeBytes) ProtoMessage() {}

func (x *MaybeBytes) ProtoReflect() protoreflect.Message {
	mi := &file_sync_sync_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use MaybeBytes.ProtoReflect.Descriptor instead.
func (*MaybeBytes) Descriptor() ([]byte, []int) {
	return file_sync_sync_proto_rawDescGZIP(), []int{8}
}

func (x *MaybeBytes) GetValue() []byte {
	if x != nil {
		return x.Value
	}
	return nil
}

type KeyValue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           []byte                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value         []byte                 `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KeyValue) Reset() {
	*x = KeyValue{}
	mi := &file_sync_sync_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KeyValue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KeyValue) ProtoMessage() {}

func (x *KeyValue) ProtoReflect() protoreflect.Message {
	mi := &file_sync_sync_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KeyValue.ProtoReflect.Descriptor instead.
func (*KeyValue) Descriptor() ([]byte, []int) {
	return file_sync_sync_proto_rawDescGZIP(), []int{9}
}

func (x *KeyValue) GetKey() []byte {
	if x != nil {
		return x.Key
	}
	return nil
}

func (x *KeyValue) GetValue() []byte {
	if x != nil {
		return x.Value
	}
	return nil
}

var File_sync_sync_proto protoreflect.FileDescriptor

const file_sync_sync_proto_rawDesc = "" +
	"\n" +
	"\x0fsync/sync.proto\x12\x04sync\"\xfb\x01\n" +
	"\x15GetChangeProofRequest\x12&\n" +
	"\x0fstart_root_hash\x18\x01 \x01(\fR\rstartRootHash\x12\"\n" +
	"\rend_root_hash\x18\x02 \x01(\fR\vendRootHash\x12-\n" +
	"\tstart_key\x18\x03 \x01(\v2\x10.sync.MaybeBytesR\bstartKey\x12)\n" +
	"\aend_key\x18\x04 \x01(\v2\x10.sync.MaybeBytesR\x06endKey\x12\x1b\n" +
	"\tkey_limit\x18\x05 \x01(\rR\bkeyLimit\x12\x1f\n" +
	"\vbytes_limit\x18\x06 \x01(\rR\n" +
	"bytesLimit\"l\n" +
	"\x16GetChangeProofResponse\x12#\n" +
	"\fchange_proof\x18\x01 \x01(\fH\x00R\vchangeProof\x12!\n" +
	"\vrange_proof\x18\x02 \x01(\fH\x00R\n" +
	"rangeProofB\n" +
	"\n" +
	"\bresponse\"\xcb\x01\n" +
	"\x14GetRangeProofRequest\x12\x1b\n" +
	"\troot_hash\x18\x01 \x01(\fR\brootHash\x12-\n" +
	"\tstart_key\x18\x02 \x01(\v2\x10.sync.MaybeBytesR\bstartKey\x12)\n" +
	"\aend_key\x18\x03 \x01(\v2\x10.sync.MaybeBytesR\x06endKey\x12\x1b\n" +
	"\tkey_limit\x18\x04 \x01(\rR\bkeyLimit\x12\x1f\n" +
	"\vbytes_limit\x18\x05 \x01(\rR\n" +
	"bytesLimit\"\x9f\x01\n" +
	"\vChangeProof\x120\n" +
	"\vstart_proof\x18\x01 \x03(\v2\x0f.sync.ProofNodeR\n" +
	"startProof\x12,\n" +
	"\tend_proof\x18\x02 \x03(\v2\x0f.sync.ProofNodeR\bendProof\x120\n" +
	"\vkey_changes\x18\x03 \x03(\v2\x0f.sync.KeyChangeR\n" +
	"keyChanges\"\x9b\x01\n" +
	"\n" +
	"RangeProof\x120\n" +
	"\vstart_proof\x18\x01 \x03(\v2\x0f.sync.ProofNodeR\n" +
	"startProof\x12,\n" +
	"\tend_proof\x18\x02 \x03(\v2\x0f.sync.ProofNodeR\bendProof\x12-\n" +
	"\n" +
	"key_values\x18\x03 \x03(\v2\x0e.sync.KeyValueR\tkeyValues\"\xd6\x01\n" +
	"\tProofNode\x12\x1b\n" +
	"\x03key\x18\x01 \x01(\v2\t.sync.KeyR\x03key\x124\n" +
	"\rvalue_or_hash\x18\x02 \x01(\v2\x10.sync.MaybeBytesR\vvalueOrHash\x129\n" +
	"\bchildren\x18\x03 \x03(\v2\x1d.sync.ProofNode.ChildrenEntryR\bchildren\x1a;\n" +
	"\rChildrenEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\rR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\fR\x05value:\x028\x01\"E\n" +
	"\tKeyChange\x12\x10\n" +
	"\x03key\x18\x01 \x01(\fR\x03key\x12&\n" +
	"\x05value\x18\x02 \x01(\v2\x10.sync.MaybeBytesR\x05value\"3\n" +
	"\x03Key\x12\x16\n" +
	"\x06length\x18\x01 \x01(\x04R\x06length\x12\x14\n" +
	"\x05value\x18\x02 \x01(\fR\x05value\"\"\n" +
	"\n" +
	"MaybeBytes\x12\x14\n" +
	"\x05value\x18\x01 \x01(\fR\x05value\"2\n" +
	"\bKeyValue\x12\x10\n" +
	"\x03key\x18\x01 \x01(\fR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\fR\x05valueB/Z-github.com/ava-labs/avalanchego/proto/pb/syncb\x06proto3"

var (
	file_sync_sync_proto_rawDescOnce sync.Once
	file_sync_sync_proto_rawDescData []byte
)

func file_sync_sync_proto_rawDescGZIP() []byte {
	file_sync_sync_proto_rawDescOnce.Do(func() {
		file_sync_sync_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_sync_sync_proto_rawDesc), len(file_sync_sync_proto_rawDesc)))
	})
	return file_sync_sync_proto_rawDescData
}

var file_sync_sync_proto_msgTypes = make([]protoimpl.MessageInfo, 11)
var file_sync_sync_proto_goTypes = []any{
	(*GetChangeProofRequest)(nil),  // 0: sync.GetChangeProofRequest
	(*GetChangeProofResponse)(nil), // 1: sync.GetChangeProofResponse
	(*GetRangeProofRequest)(nil),   // 2: sync.GetRangeProofRequest
	(*ChangeProof)(nil),            // 3: sync.ChangeProof
	(*RangeProof)(nil),             // 4: sync.RangeProof
	(*ProofNode)(nil),              // 5: sync.ProofNode
	(*KeyChange)(nil),              // 6: sync.KeyChange
	(*Key)(nil),                    // 7: sync.Key
	(*MaybeBytes)(nil),             // 8: sync.MaybeBytes
	(*KeyValue)(nil),               // 9: sync.KeyValue
	nil,                            // 10: sync.ProofNode.ChildrenEntry
}
var file_sync_sync_proto_depIdxs = []int32{
	8,  // 0: sync.GetChangeProofRequest.start_key:type_name -> sync.MaybeBytes
	8,  // 1: sync.GetChangeProofRequest.end_key:type_name -> sync.MaybeBytes
	8,  // 2: sync.GetRangeProofRequest.start_key:type_name -> sync.MaybeBytes
	8,  // 3: sync.GetRangeProofRequest.end_key:type_name -> sync.MaybeBytes
	5,  // 4: sync.ChangeProof.start_proof:type_name -> sync.ProofNode
	5,  // 5: sync.ChangeProof.end_proof:type_name -> sync.ProofNode
	6,  // 6: sync.ChangeProof.key_changes:type_name -> sync.KeyChange
	5,  // 7: sync.RangeProof.start_proof:type_name -> sync.ProofNode
	5,  // 8: sync.RangeProof.end_proof:type_name -> sync.ProofNode
	9,  // 9: sync.RangeProof.key_values:type_name -> sync.KeyValue
	7,  // 10: sync.ProofNode.key:type_name -> sync.Key
	8,  // 11: sync.ProofNode.value_or_hash:type_name -> sync.MaybeBytes
	10, // 12: sync.ProofNode.children:type_name -> sync.ProofNode.ChildrenEntry
	8,  // 13: sync.KeyChange.value:type_name -> sync.MaybeBytes
	14, // [14:14] is the sub-list for method output_type
	14, // [14:14] is the sub-list for method input_type
	14, // [14:14] is the sub-list for extension type_name
	14, // [14:14] is the sub-list for extension extendee
	0,  // [0:14] is the sub-list for field type_name
}

func init() { file_sync_sync_proto_init() }
func file_sync_sync_proto_init() {
	if File_sync_sync_proto != nil {
		return
	}
	file_sync_sync_proto_msgTypes[1].OneofWrappers = []any{
		(*GetChangeProofResponse_ChangeProof)(nil),
		(*GetChangeProofResponse_RangeProof)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_sync_sync_proto_rawDesc), len(file_sync_sync_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   11,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_sync_sync_proto_goTypes,
		DependencyIndexes: file_sync_sync_proto_depIdxs,
		MessageInfos:      file_sync_sync_proto_msgTypes,
	}.Build()
	File_sync_sync_proto = out.File
	file_sync_sync_proto_goTypes = nil
	file_sync_sync_proto_depIdxs = nil
}
