any-sync/commonspace/object/tree/treechangeproto/treechange.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: commonspace/object/tree/treechangeproto/protos/treechange.proto

package treechangeproto

import (
	fmt "fmt"
	proto "github.com/anyproto/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type ErrorCodes int32

const (
	ErrorCodes_Unexpected           ErrorCodes = 0
	ErrorCodes_GetTreeError         ErrorCodes = 1
	ErrorCodes_FullSyncRequestError ErrorCodes = 2
	ErrorCodes_ErrorOffset          ErrorCodes = 400
)

var ErrorCodes_name = map[int32]string{
	0:   "Unexpected",
	1:   "GetTreeError",
	2:   "FullSyncRequestError",
	400: "ErrorOffset",
}

var ErrorCodes_value = map[string]int32{
	"Unexpected":           0,
	"GetTreeError":         1,
	"FullSyncRequestError": 2,
	"ErrorOffset":          400,
}

func (x ErrorCodes) String() string {
	return proto.EnumName(ErrorCodes_name, int32(x))
}

func (ErrorCodes) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5033f0301ef9b772, []int{0}
}

// RootChange is a root of a tree
type RootChange struct {
	// AclHeadId is a cid of latest acl record at the time of tree creation
	AclHeadId string `protobuf:"bytes,1,opt,name=aclHeadId,proto3" json:"aclHeadId,omitempty"`
	// SpaceId is an id of space where the document is placed
	SpaceId string `protobuf:"bytes,2,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
	// ChangeType is a type of tree which this RootChange is a root of
	ChangeType string `protobuf:"bytes,3,opt,name=changeType,proto3" json:"changeType,omitempty"`
	// Timestamp is this change creation timestamp
	Timestamp int64 `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// Seed is a random bytes to make root change unique
	Seed []byte `protobuf:"bytes,5,opt,name=seed,proto3" json:"seed,omitempty"`
	// Identity is a public key of the tree's creator
	Identity []byte `protobuf:"bytes,6,opt,name=identity,proto3" json:"identity,omitempty"`
	// ChangePayload is a payload related to ChangeType
	ChangePayload []byte `protobuf:"bytes,7,opt,name=changePayload,proto3" json:"changePayload,omitempty"`
	// IsDerived tells if the tree is derived
	IsDerived bool `protobuf:"varint,8,opt,name=isDerived,proto3" json:"isDerived,omitempty"`
}

func (m *RootChange) Reset()         { *m = RootChange{} }
func (m *RootChange) String() string { return proto.CompactTextString(m) }
func (*RootChange) ProtoMessage()    {}
func (*RootChange) Descriptor() ([]byte, []int) {
	return fileDescriptor_5033f0301ef9b772, []int{0}
}
func (m *RootChange) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RootChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RootChange.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RootChange) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
	b = b[:newLen]
	_, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b, nil
}
func (m *RootChange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RootChange.Merge(m, src)
}
func (m *RootChange) XXX_Size() int {
	return m.Size()
}
func (m *RootChange) XXX_DiscardUnknown() {
	xxx_messageInfo_RootChange.DiscardUnknown(m)
}

var xxx_messageInfo_RootChange proto.InternalMessageInfo

func (m *RootChange) GetAclHeadId() string {
	if m != nil {
		return m.AclHeadId
	}
	return ""
}

func (m *RootChange) GetSpaceId() string {
	if m != nil {
		return m.SpaceId
	}
	return ""
}

func (m *RootChange) GetChangeType() string {
	if m != nil {
		return m.ChangeType
	}
	return ""
}

func (m *RootChange) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *RootChange) GetSeed() []byte {
	if m != nil {
		return m.Seed
	}
	return nil
}

func (m *RootChange) GetIdentity() []byte {
	if m != nil {
		return m.Identity
	}
	return nil
}

func (m *RootChange) GetChangePayload() []byte {
	if m != nil {
		return m.ChangePayload
	}
	return nil
}

func (m *RootChange) GetIsDerived() bool {
	if m != nil {
		return m.IsDerived
	}
	return false
}

// TreeChange is a change of a tree
type TreeChange struct {
	// TreeHeadIds are previous ids for this TreeChange
	TreeHeadIds []string `protobuf:"bytes,1,rep,name=treeHeadIds,proto3" json:"treeHeadIds,omitempty"`
	// AclHeadId is a cid of latest acl record at the time of this change
	AclHeadId string `protobuf:"bytes,2,opt,name=aclHeadId,proto3" json:"aclHeadId,omitempty"`
	// SnapshotBaseId is a snapshot (root) of the tree where this change is added
	SnapshotBaseId string `protobuf:"bytes,3,opt,name=snapshotBaseId,proto3" json:"snapshotBaseId,omitempty"`
	// ChangesData is an arbitrary payload to be read by the client
	ChangesData []byte `protobuf:"bytes,4,opt,name=changesData,proto3" json:"changesData,omitempty"`
	// ReadKeyId is the id of the read key
	ReadKeyId string `protobuf:"bytes,5,opt,name=readKeyId,proto3" json:"readKeyId,omitempty"`
	// Timestamp is this change creation timestamp
	Timestamp int64 `protobuf:"varint,6,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// Identity is a public key with which the raw payload of this change is signed
	Identity []byte `protobuf:"bytes,7,opt,name=identity,proto3" json:"identity,omitempty"`
	// IsSnapshot indicates whether this change contains a snapshot of state
	IsSnapshot bool `protobuf:"varint,8,opt,name=isSnapshot,proto3" json:"isSnapshot,omitempty"`
	// DataType indicates some special parameters of data for the client
	DataType string `protobuf:"bytes,9,opt,name=dataType,proto3" json:"dataType,omitempty"`
}

func (m *TreeChange) Reset()         { *m = TreeChange{} }
func (m *TreeChange) String() string { return proto.CompactTextString(m) }
func (*TreeChange) ProtoMessage()    {}
func (*TreeChange) Descriptor() ([]byte, []int) {
	return fileDescriptor_5033f0301ef9b772, []int{1}
}
func (m *TreeChange) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TreeChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TreeChange.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TreeChange) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
	b = b[:newLen]
	_, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b, nil
}
func (m *TreeChange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TreeChange.Merge(m, src)
}
func (m *TreeChange) XXX_Size() int {
	return m.Size()
}
func (m *TreeChange) XXX_DiscardUnknown() {
	xxx_messageInfo_TreeChange.DiscardUnknown(m)
}

var xxx_messageInfo_TreeChange proto.InternalMessageInfo

func (m *TreeChange) GetTreeHeadIds() []string {
	if m != nil {
		return m.TreeHeadIds
	}
	return nil
}

func (m *TreeChange) GetAclHeadId() string {
	if m != nil {
		return m.AclHeadId
	}
	return ""
}

func (m *TreeChange) GetSnapshotBaseId() string {
	if m != nil {
		return m.SnapshotBaseId
	}
	return ""
}

func (m *TreeChange) GetChangesData() []byte {
	if m != nil {
		return m.ChangesData
	}
	return nil
}

func (m *TreeChange) GetReadKeyId() string {
	if m != nil {
		return m.ReadKeyId
	}
	return ""
}

func (m *TreeChange) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *TreeChange) GetIdentity() []byte {
	if m != nil {
		return m.Identity
	}
	return nil
}

func (m *TreeChange) GetIsSnapshot() bool {
	if m != nil {
		return m.IsSnapshot
	}
	return false
}

func (m *TreeChange) GetDataType() string {
	if m != nil {
		return m.DataType
	}
	return ""
}

// TreeChange is a change of a tree
type NoDataTreeChange struct {
	// TreeHeadIds are previous ids for this TreeChange
	TreeHeadIds []string `protobuf:"bytes,1,rep,name=treeHeadIds,proto3" json:"treeHeadIds,omitempty"`
	// AclHeadId is a cid of latest acl record at the time of this change
	AclHeadId string `protobuf:"bytes,2,opt,name=aclHeadId,proto3" json:"aclHeadId,omitempty"`
	// SnapshotBaseId is a snapshot (root) of the tree where this change is added
	SnapshotBaseId string `protobuf:"bytes,3,opt,name=snapshotBaseId,proto3" json:"snapshotBaseId,omitempty"`
	// ReadKeyId is the id of the read key
	ReadKeyId string `protobuf:"bytes,5,opt,name=readKeyId,proto3" json:"readKeyId,omitempty"`
	// Timestamp is this change creation timestamp
	Timestamp int64 `protobuf:"varint,6,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// Identity is a public key with which the raw payload of this change is signed
	Identity []byte `protobuf:"bytes,7,opt,name=identity,proto3" json:"identity,omitempty"`
	// IsSnapshot indicates whether this change contains a snapshot of state
	IsSnapshot bool `protobuf:"varint,8,opt,name=isSnapshot,proto3" json:"isSnapshot,omitempty"`
	// DataType indicates some special parameters of data for the client
	DataType string `protobuf:"bytes,9,opt,name=dataType,proto3" json:"dataType,omitempty"`
}

func (m *NoDataTreeChange) Reset()         { *m = NoDataTreeChange{} }
func (m *NoDataTreeChange) String() string { return proto.CompactTextString(m) }
func (*NoDataTreeChange) ProtoMessage()    {}
func (*NoDataTreeChange) Descriptor() ([]byte, []int) {
	return fileDescriptor_5033f0301ef9b772, []int{2}
}
func (m *NoDataTreeChange) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NoDataTreeChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NoDataTreeChange.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *NoDataTreeChange) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
	b = b[:newLen]
	_, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b, nil
}
func (m *NoDataTreeChange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NoDataTreeChange.Merge(m, src)
}
func (m *NoDataTreeChange) XXX_Size() int {
	return m.Size()
}
func (m *NoDataTreeChange) XXX_DiscardUnknown() {
	xxx_messageInfo_NoDataTreeChange.DiscardUnknown(m)
}

var xxx_messageInfo_NoDataTreeChange proto.InternalMessageInfo

func (m *NoDataTreeChange) GetTreeHeadIds() []string {
	if m != nil {
		return m.TreeHeadIds
	}
	return nil
}

func (m *NoDataTreeChange) GetAclHeadId() string {
	if m != nil {
		return m.AclHeadId
	}
	return ""
}

func (m *NoDataTreeChange) GetSnapshotBaseId() string {
	if m != nil {
		return m.SnapshotBaseId
	}
	return ""
}

func (m *NoDataTreeChange) GetReadKeyId() string {
	if m != nil {
		return m.ReadKeyId
	}
	return ""
}

func (m *NoDataTreeChange) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *NoDataTreeChange) GetIdentity() []byte {
	if m != nil {
		return m.Identity
	}
	return nil
}

func (m *NoDataTreeChange) GetIsSnapshot() bool {
	if m != nil {
		return m.IsSnapshot
	}
	return false
}

func (m *NoDataTreeChange) GetDataType() string {
	if m != nil {
		return m.DataType
	}
	return ""
}

type ReducedTreeChange struct {
	// TreeHeadIds are previous ids for this TreeChange
	TreeHeadIds []string `protobuf:"bytes,1,rep,name=treeHeadIds,proto3" json:"treeHeadIds,omitempty"`
}

func (m *ReducedTreeChange) Reset()         { *m = ReducedTreeChange{} }
func (m *ReducedTreeChange) String() string { return proto.CompactTextString(m) }
func (*ReducedTreeChange) ProtoMessage()    {}
func (*ReducedTreeChange) Descriptor() ([]byte, []int) {
	return fileDescriptor_5033f0301ef9b772, []int{3}
}
func (m *ReducedTreeChange) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReducedTreeChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReducedTreeChange.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ReducedTreeChange) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
	b = b[:newLen]
	_, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b, nil
}
func (m *ReducedTreeChange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReducedTreeChange.Merge(m, src)
}
func (m *ReducedTreeChange) XXX_Size() int {
	return m.Size()
}
func (m *ReducedTreeChange) XXX_DiscardUnknown() {
	xxx_messageInfo_ReducedTreeChange.DiscardUnknown(m)
}

var xxx_messageInfo_ReducedTreeChange proto.InternalMessageInfo

func (m *ReducedTreeChange) GetTreeHeadIds() []string {
	if m != nil {
		return m.TreeHeadIds
	}
	return nil
}

// RawTreeChange is a marshalled TreeChange (or RootChange) payload and a signature of this payload
type RawTreeChange struct {
	// Payload is a byte payload containing TreeChange
	Payload []byte `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	// Signature is a signature made by identity indicated in the TreeChange payload
	Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
}

func (m *RawTreeChange) Reset()         { *m = RawTreeChange{} }
func (m *RawTreeChange) String() string { return proto.CompactTextString(m) }
func (*RawTreeChange) ProtoMessage()    {}
func (*RawTreeChange) Descriptor() ([]byte, []int) {
	return fileDescriptor_5033f0301ef9b772, []int{4}
}
func (m *RawTreeChange) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RawTreeChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RawTreeChange.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RawTreeChange) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
	b = b[:newLen]
	_, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b, nil
}
func (m *RawTreeChange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RawTreeChange.Merge(m, src)
}
func (m *RawTreeChange) XXX_Size() int {
	return m.Size()
}
func (m *RawTreeChange) XXX_DiscardUnknown() {
	xxx_messageInfo_RawTreeChange.DiscardUnknown(m)
}

var xxx_messageInfo_RawTreeChange proto.InternalMessageInfo

func (m *RawTreeChange) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

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

// RawTreeChangeWithId is a marshalled RawTreeChange with CID
type RawTreeChangeWithId struct {
	// RawChange is a byte payload of RawTreeChange
	RawChange []byte `protobuf:"bytes,1,opt,name=rawChange,proto3" json:"rawChange,omitempty"`
	// Id is a cid made from rawChange payload
	Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *RawTreeChangeWithId) Reset()         { *m = RawTreeChangeWithId{} }
func (m *RawTreeChangeWithId) String() string { return proto.CompactTextString(m) }
func (*RawTreeChangeWithId) ProtoMessage()    {}
func (*RawTreeChangeWithId) Descriptor() ([]byte, []int) {
	return fileDescriptor_5033f0301ef9b772, []int{5}
}
func (m *RawTreeChangeWithId) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RawTreeChangeWithId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RawTreeChangeWithId.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RawTreeChangeWithId) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
	b = b[:newLen]
	_, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b, nil
}
func (m *RawTreeChangeWithId) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RawTreeChangeWithId.Merge(m, src)
}
func (m *RawTreeChangeWithId) XXX_Size() int {
	return m.Size()
}
func (m *RawTreeChangeWithId) XXX_DiscardUnknown() {
	xxx_messageInfo_RawTreeChangeWithId.DiscardUnknown(m)
}

var xxx_messageInfo_RawTreeChangeWithId proto.InternalMessageInfo

func (m *RawTreeChangeWithId) GetRawChange() []byte {
	if m != nil {
		return m.RawChange
	}
	return nil
}

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

type TreeSyncMessage struct {
	Content    *TreeSyncContentValue `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"`
	RootChange *RawTreeChangeWithId  `protobuf:"bytes,2,opt,name=rootChange,proto3" json:"rootChange,omitempty"`
}

func (m *TreeSyncMessage) Reset()         { *m = TreeSyncMessage{} }
func (m *TreeSyncMessage) String() string { return proto.CompactTextString(m) }
func (*TreeSyncMessage) ProtoMessage()    {}
func (*TreeSyncMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_5033f0301ef9b772, []int{6}
}
func (m *TreeSyncMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TreeSyncMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TreeSyncMessage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TreeSyncMessage) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
	b = b[:newLen]
	_, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b, nil
}
func (m *TreeSyncMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TreeSyncMessage.Merge(m, src)
}
func (m *TreeSyncMessage) XXX_Size() int {
	return m.Size()
}
func (m *TreeSyncMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_TreeSyncMessage.DiscardUnknown(m)
}

var xxx_messageInfo_TreeSyncMessage proto.InternalMessageInfo

func (m *TreeSyncMessage) GetContent() *TreeSyncContentValue {
	if m != nil {
		return m.Content
	}
	return nil
}

func (m *TreeSyncMessage) GetRootChange() *RawTreeChangeWithId {
	if m != nil {
		return m.RootChange
	}
	return nil
}

// TreeSyncContentValue provides different types for tree sync
type TreeSyncContentValue struct {
	// Types that are valid to be assigned to Value:
	//
	//	*TreeSyncContentValue_HeadUpdate
	//	*TreeSyncContentValue_FullSyncRequest
	//	*TreeSyncContentValue_FullSyncResponse
	//	*TreeSyncContentValue_ErrorResponse
	Value isTreeSyncContentValueValue `protobuf_oneof:"value"`
}

func (m *TreeSyncContentValue) Reset()         { *m = TreeSyncContentValue{} }
func (m *TreeSyncContentValue) String() string { return proto.CompactTextString(m) }
func (*TreeSyncContentValue) ProtoMessage()    {}
func (*TreeSyncContentValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_5033f0301ef9b772, []int{7}
}
func (m *TreeSyncContentValue) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TreeSyncContentValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TreeSyncContentValue.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TreeSyncContentValue) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
	b = b[:newLen]
	_, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b, nil
}
func (m *TreeSyncContentValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TreeSyncContentValue.Merge(m, src)
}
func (m *TreeSyncContentValue) XXX_Size() int {
	return m.Size()
}
func (m *TreeSyncContentValue) XXX_DiscardUnknown() {
	xxx_messageInfo_TreeSyncContentValue.DiscardUnknown(m)
}

var xxx_messageInfo_TreeSyncContentValue proto.InternalMessageInfo

type isTreeSyncContentValueValue interface {
	isTreeSyncContentValueValue()
	MarshalTo([]byte) (int, error)
	Size() int
}

type TreeSyncContentValue_HeadUpdate struct {
	HeadUpdate *TreeHeadUpdate `protobuf:"bytes,1,opt,name=headUpdate,proto3,oneof" json:"headUpdate,omitempty"`
}
type TreeSyncContentValue_FullSyncRequest struct {
	FullSyncRequest *TreeFullSyncRequest `protobuf:"bytes,2,opt,name=fullSyncRequest,proto3,oneof" json:"fullSyncRequest,omitempty"`
}
type TreeSyncContentValue_FullSyncResponse struct {
	FullSyncResponse *TreeFullSyncResponse `protobuf:"bytes,3,opt,name=fullSyncResponse,proto3,oneof" json:"fullSyncResponse,omitempty"`
}
type TreeSyncContentValue_ErrorResponse struct {
	ErrorResponse *TreeErrorResponse `protobuf:"bytes,4,opt,name=errorResponse,proto3,oneof" json:"errorResponse,omitempty"`
}

func (*TreeSyncContentValue_HeadUpdate) isTreeSyncContentValueValue()       {}
func (*TreeSyncContentValue_FullSyncRequest) isTreeSyncContentValueValue()  {}
func (*TreeSyncContentValue_FullSyncResponse) isTreeSyncContentValueValue() {}
func (*TreeSyncContentValue_ErrorResponse) isTreeSyncContentValueValue()    {}

func (m *TreeSyncContentValue) GetValue() isTreeSyncContentValueValue {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *TreeSyncContentValue) GetHeadUpdate() *TreeHeadUpdate {
	if x, ok := m.GetValue().(*TreeSyncContentValue_HeadUpdate); ok {
		return x.HeadUpdate
	}
	return nil
}

func (m *TreeSyncContentValue) GetFullSyncRequest() *TreeFullSyncRequest {
	if x, ok := m.GetValue().(*TreeSyncContentValue_FullSyncRequest); ok {
		return x.FullSyncRequest
	}
	return nil
}

func (m *TreeSyncContentValue) GetFullSyncResponse() *TreeFullSyncResponse {
	if x, ok := m.GetValue().(*TreeSyncContentValue_FullSyncResponse); ok {
		return x.FullSyncResponse
	}
	return nil
}

func (m *TreeSyncContentValue) GetErrorResponse() *TreeErrorResponse {
	if x, ok := m.GetValue().(*TreeSyncContentValue_ErrorResponse); ok {
		return x.ErrorResponse
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*TreeSyncContentValue) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*TreeSyncContentValue_HeadUpdate)(nil),
		(*TreeSyncContentValue_FullSyncRequest)(nil),
		(*TreeSyncContentValue_FullSyncResponse)(nil),
		(*TreeSyncContentValue_ErrorResponse)(nil),
	}
}

// TreeHeadUpdate is a message sent on document head update
type TreeHeadUpdate struct {
	Heads        []string               `protobuf:"bytes,1,rep,name=heads,proto3" json:"heads,omitempty"`
	Changes      []*RawTreeChangeWithId `protobuf:"bytes,2,rep,name=changes,proto3" json:"changes,omitempty"`
	SnapshotPath []string               `protobuf:"bytes,3,rep,name=snapshotPath,proto3" json:"snapshotPath,omitempty"`
}

func (m *TreeHeadUpdate) Reset()         { *m = TreeHeadUpdate{} }
func (m *TreeHeadUpdate) String() string { return proto.CompactTextString(m) }
func (*TreeHeadUpdate) ProtoMessage()    {}
func (*TreeHeadUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_5033f0301ef9b772, []int{8}
}
func (m *TreeHeadUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TreeHeadUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TreeHeadUpdate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TreeHeadUpdate) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
	b = b[:newLen]
	_, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b, nil
}
func (m *TreeHeadUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TreeHeadUpdate.Merge(m, src)
}
func (m *TreeHeadUpdate) XXX_Size() int {
	return m.Size()
}
func (m *TreeHeadUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_TreeHeadUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_TreeHeadUpdate proto.InternalMessageInfo

func (m *TreeHeadUpdate) GetHeads() []string {
	if m != nil {
		return m.Heads
	}
	return nil
}

func (m *TreeHeadUpdate) GetChanges() []*RawTreeChangeWithId {
	if m != nil {
		return m.Changes
	}
	return nil
}

func (m *TreeHeadUpdate) GetSnapshotPath() []string {
	if m != nil {
		return m.SnapshotPath
	}
	return nil
}

// TreeHeadUpdate is a message sent when document needs full sync
type TreeFullSyncRequest struct {
	Heads        []string               `protobuf:"bytes,1,rep,name=heads,proto3" json:"heads,omitempty"`
	Changes      []*RawTreeChangeWithId `protobuf:"bytes,2,rep,name=changes,proto3" json:"changes,omitempty"`
	SnapshotPath []string               `protobuf:"bytes,3,rep,name=snapshotPath,proto3" json:"snapshotPath,omitempty"`
}

func (m *TreeFullSyncRequest) Reset()         { *m = TreeFullSyncRequest{} }
func (m *TreeFullSyncRequest) String() string { return proto.CompactTextString(m) }
func (*TreeFullSyncRequest) ProtoMessage()    {}
func (*TreeFullSyncRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_5033f0301ef9b772, []int{9}
}
func (m *TreeFullSyncRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TreeFullSyncRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TreeFullSyncRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TreeFullSyncRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
	b = b[:newLen]
	_, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b, nil
}
func (m *TreeFullSyncRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TreeFullSyncRequest.Merge(m, src)
}
func (m *TreeFullSyncRequest) XXX_Size() int {
	return m.Size()
}
func (m *TreeFullSyncRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TreeFullSyncRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TreeFullSyncRequest proto.InternalMessageInfo

func (m *TreeFullSyncRequest) GetHeads() []string {
	if m != nil {
		return m.Heads
	}
	return nil
}

func (m *TreeFullSyncRequest) GetChanges() []*RawTreeChangeWithId {
	if m != nil {
		return m.Changes
	}
	return nil
}

func (m *TreeFullSyncRequest) GetSnapshotPath() []string {
	if m != nil {
		return m.SnapshotPath
	}
	return nil
}

// TreeFullSyncResponse is a message sent as a response for a specific full sync
type TreeFullSyncResponse struct {
	Heads        []string               `protobuf:"bytes,1,rep,name=heads,proto3" json:"heads,omitempty"`
	Changes      []*RawTreeChangeWithId `protobuf:"bytes,2,rep,name=changes,proto3" json:"changes,omitempty"`
	SnapshotPath []string               `protobuf:"bytes,3,rep,name=snapshotPath,proto3" json:"snapshotPath,omitempty"`
}

func (m *TreeFullSyncResponse) Reset()         { *m = TreeFullSyncResponse{} }
func (m *TreeFullSyncResponse) String() string { return proto.CompactTextString(m) }
func (*TreeFullSyncResponse) ProtoMessage()    {}
func (*TreeFullSyncResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_5033f0301ef9b772, []int{10}
}
func (m *TreeFullSyncResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TreeFullSyncResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TreeFullSyncResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TreeFullSyncResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
	b = b[:newLen]
	_, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b, nil
}
func (m *TreeFullSyncResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TreeFullSyncResponse.Merge(m, src)
}
func (m *TreeFullSyncResponse) XXX_Size() int {
	return m.Size()
}
func (m *TreeFullSyncResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TreeFullSyncResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TreeFullSyncResponse proto.InternalMessageInfo

func (m *TreeFullSyncResponse) GetHeads() []string {
	if m != nil {
		return m.Heads
	}
	return nil
}

func (m *TreeFullSyncResponse) GetChanges() []*RawTreeChangeWithId {
	if m != nil {
		return m.Changes
	}
	return nil
}

func (m *TreeFullSyncResponse) GetSnapshotPath() []string {
	if m != nil {
		return m.SnapshotPath
	}
	return nil
}

// TreeErrorResponse is an error sent as a response for a full sync request
type TreeErrorResponse struct {
	Error   string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	ErrCode uint64 `protobuf:"varint,2,opt,name=errCode,proto3" json:"errCode,omitempty"`
}

func (m *TreeErrorResponse) Reset()         { *m = TreeErrorResponse{} }
func (m *TreeErrorResponse) String() string { return proto.CompactTextString(m) }
func (*TreeErrorResponse) ProtoMessage()    {}
func (*TreeErrorResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_5033f0301ef9b772, []int{11}
}
func (m *TreeErrorResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TreeErrorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TreeErrorResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TreeErrorResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
	b = b[:newLen]
	_, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b, nil
}
func (m *TreeErrorResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TreeErrorResponse.Merge(m, src)
}
func (m *TreeErrorResponse) XXX_Size() int {
	return m.Size()
}
func (m *TreeErrorResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TreeErrorResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TreeErrorResponse proto.InternalMessageInfo

func (m *TreeErrorResponse) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

func (m *TreeErrorResponse) GetErrCode() uint64 {
	if m != nil {
		return m.ErrCode
	}
	return 0
}

// TreeChangeInfo is used internally in Tree implementation for ease of marshalling
type TreeChangeInfo struct {
	ChangeType    string `protobuf:"bytes,1,opt,name=changeType,proto3" json:"changeType,omitempty"`
	ChangePayload []byte `protobuf:"bytes,2,opt,name=changePayload,proto3" json:"changePayload,omitempty"`
}

func (m *TreeChangeInfo) Reset()         { *m = TreeChangeInfo{} }
func (m *TreeChangeInfo) String() string { return proto.CompactTextString(m) }
func (*TreeChangeInfo) ProtoMessage()    {}
func (*TreeChangeInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_5033f0301ef9b772, []int{12}
}
func (m *TreeChangeInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TreeChangeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TreeChangeInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TreeChangeInfo) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
	b = b[:newLen]
	_, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b, nil
}
func (m *TreeChangeInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TreeChangeInfo.Merge(m, src)
}
func (m *TreeChangeInfo) XXX_Size() int {
	return m.Size()
}
func (m *TreeChangeInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_TreeChangeInfo.DiscardUnknown(m)
}

var xxx_messageInfo_TreeChangeInfo proto.InternalMessageInfo

func (m *TreeChangeInfo) GetChangeType() string {
	if m != nil {
		return m.ChangeType
	}
	return ""
}

func (m *TreeChangeInfo) GetChangePayload() []byte {
	if m != nil {
		return m.ChangePayload
	}
	return nil
}

func init() {
	proto.RegisterEnum("treechange.ErrorCodes", ErrorCodes_name, ErrorCodes_value)
	proto.RegisterType((*RootChange)(nil), "treechange.RootChange")
	proto.RegisterType((*TreeChange)(nil), "treechange.TreeChange")
	proto.RegisterType((*NoDataTreeChange)(nil), "treechange.NoDataTreeChange")
	proto.RegisterType((*ReducedTreeChange)(nil), "treechange.ReducedTreeChange")
	proto.RegisterType((*RawTreeChange)(nil), "treechange.RawTreeChange")
	proto.RegisterType((*RawTreeChangeWithId)(nil), "treechange.RawTreeChangeWithId")
	proto.RegisterType((*TreeSyncMessage)(nil), "treechange.TreeSyncMessage")
	proto.RegisterType((*TreeSyncContentValue)(nil), "treechange.TreeSyncContentValue")
	proto.RegisterType((*TreeHeadUpdate)(nil), "treechange.TreeHeadUpdate")
	proto.RegisterType((*TreeFullSyncRequest)(nil), "treechange.TreeFullSyncRequest")
	proto.RegisterType((*TreeFullSyncResponse)(nil), "treechange.TreeFullSyncResponse")
	proto.RegisterType((*TreeErrorResponse)(nil), "treechange.TreeErrorResponse")
	proto.RegisterType((*TreeChangeInfo)(nil), "treechange.TreeChangeInfo")
}

func init() {
	proto.RegisterFile("commonspace/object/tree/treechangeproto/protos/treechange.proto", fileDescriptor_5033f0301ef9b772)
}

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

func (m *RootChange) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RootChange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RootChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsDerived {
		i--
		if m.IsDerived {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if len(m.ChangePayload) > 0 {
		i -= len(m.ChangePayload)
		copy(dAtA[i:], m.ChangePayload)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.ChangePayload)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Identity) > 0 {
		i -= len(m.Identity)
		copy(dAtA[i:], m.Identity)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.Identity)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Seed) > 0 {
		i -= len(m.Seed)
		copy(dAtA[i:], m.Seed)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.Seed)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Timestamp != 0 {
		i = encodeVarintTreechange(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x20
	}
	if len(m.ChangeType) > 0 {
		i -= len(m.ChangeType)
		copy(dAtA[i:], m.ChangeType)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.ChangeType)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.SpaceId) > 0 {
		i -= len(m.SpaceId)
		copy(dAtA[i:], m.SpaceId)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.SpaceId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AclHeadId) > 0 {
		i -= len(m.AclHeadId)
		copy(dAtA[i:], m.AclHeadId)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.AclHeadId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TreeChange) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TreeChange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TreeChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DataType) > 0 {
		i -= len(m.DataType)
		copy(dAtA[i:], m.DataType)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.DataType)))
		i--
		dAtA[i] = 0x4a
	}
	if m.IsSnapshot {
		i--
		if m.IsSnapshot {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if len(m.Identity) > 0 {
		i -= len(m.Identity)
		copy(dAtA[i:], m.Identity)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.Identity)))
		i--
		dAtA[i] = 0x3a
	}
	if m.Timestamp != 0 {
		i = encodeVarintTreechange(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x30
	}
	if len(m.ReadKeyId) > 0 {
		i -= len(m.ReadKeyId)
		copy(dAtA[i:], m.ReadKeyId)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.ReadKeyId)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ChangesData) > 0 {
		i -= len(m.ChangesData)
		copy(dAtA[i:], m.ChangesData)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.ChangesData)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.SnapshotBaseId) > 0 {
		i -= len(m.SnapshotBaseId)
		copy(dAtA[i:], m.SnapshotBaseId)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.SnapshotBaseId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.AclHeadId) > 0 {
		i -= len(m.AclHeadId)
		copy(dAtA[i:], m.AclHeadId)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.AclHeadId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.TreeHeadIds) > 0 {
		for iNdEx := len(m.TreeHeadIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.TreeHeadIds[iNdEx])
			copy(dAtA[i:], m.TreeHeadIds[iNdEx])
			i = encodeVarintTreechange(dAtA, i, uint64(len(m.TreeHeadIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *NoDataTreeChange) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NoDataTreeChange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NoDataTreeChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DataType) > 0 {
		i -= len(m.DataType)
		copy(dAtA[i:], m.DataType)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.DataType)))
		i--
		dAtA[i] = 0x4a
	}
	if m.IsSnapshot {
		i--
		if m.IsSnapshot {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if len(m.Identity) > 0 {
		i -= len(m.Identity)
		copy(dAtA[i:], m.Identity)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.Identity)))
		i--
		dAtA[i] = 0x3a
	}
	if m.Timestamp != 0 {
		i = encodeVarintTreechange(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x30
	}
	if len(m.ReadKeyId) > 0 {
		i -= len(m.ReadKeyId)
		copy(dAtA[i:], m.ReadKeyId)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.ReadKeyId)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.SnapshotBaseId) > 0 {
		i -= len(m.SnapshotBaseId)
		copy(dAtA[i:], m.SnapshotBaseId)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.SnapshotBaseId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.AclHeadId) > 0 {
		i -= len(m.AclHeadId)
		copy(dAtA[i:], m.AclHeadId)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.AclHeadId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.TreeHeadIds) > 0 {
		for iNdEx := len(m.TreeHeadIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.TreeHeadIds[iNdEx])
			copy(dAtA[i:], m.TreeHeadIds[iNdEx])
			i = encodeVarintTreechange(dAtA, i, uint64(len(m.TreeHeadIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ReducedTreeChange) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ReducedTreeChange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReducedTreeChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TreeHeadIds) > 0 {
		for iNdEx := len(m.TreeHeadIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.TreeHeadIds[iNdEx])
			copy(dAtA[i:], m.TreeHeadIds[iNdEx])
			i = encodeVarintTreechange(dAtA, i, uint64(len(m.TreeHeadIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RawTreeChange) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RawTreeChange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *RawTreeChangeWithId) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RawTreeChangeWithId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *TreeSyncMessage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TreeSyncMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *TreeSyncContentValue) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TreeSyncContentValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TreeSyncContentValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != nil {
		{
			size := m.Value.Size()
			i -= size
			if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *TreeSyncContentValue_HeadUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TreeSyncContentValue_HeadUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.HeadUpdate != nil {
		{
			size, err := m.HeadUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTreechange(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *TreeSyncContentValue_FullSyncRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TreeSyncContentValue_FullSyncRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.FullSyncRequest != nil {
		{
			size, err := m.FullSyncRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTreechange(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *TreeSyncContentValue_FullSyncResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TreeSyncContentValue_FullSyncResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.FullSyncResponse != nil {
		{
			size, err := m.FullSyncResponse.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTreechange(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *TreeSyncContentValue_ErrorResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TreeSyncContentValue_ErrorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ErrorResponse != nil {
		{
			size, err := m.ErrorResponse.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTreechange(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *TreeHeadUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TreeHeadUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TreeHeadUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SnapshotPath) > 0 {
		for iNdEx := len(m.SnapshotPath) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SnapshotPath[iNdEx])
			copy(dAtA[i:], m.SnapshotPath[iNdEx])
			i = encodeVarintTreechange(dAtA, i, uint64(len(m.SnapshotPath[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Changes) > 0 {
		for iNdEx := len(m.Changes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Changes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTreechange(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Heads) > 0 {
		for iNdEx := len(m.Heads) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Heads[iNdEx])
			copy(dAtA[i:], m.Heads[iNdEx])
			i = encodeVarintTreechange(dAtA, i, uint64(len(m.Heads[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *TreeFullSyncRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TreeFullSyncRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TreeFullSyncRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SnapshotPath) > 0 {
		for iNdEx := len(m.SnapshotPath) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SnapshotPath[iNdEx])
			copy(dAtA[i:], m.SnapshotPath[iNdEx])
			i = encodeVarintTreechange(dAtA, i, uint64(len(m.SnapshotPath[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Changes) > 0 {
		for iNdEx := len(m.Changes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Changes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTreechange(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Heads) > 0 {
		for iNdEx := len(m.Heads) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Heads[iNdEx])
			copy(dAtA[i:], m.Heads[iNdEx])
			i = encodeVarintTreechange(dAtA, i, uint64(len(m.Heads[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *TreeFullSyncResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TreeFullSyncResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TreeFullSyncResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SnapshotPath) > 0 {
		for iNdEx := len(m.SnapshotPath) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SnapshotPath[iNdEx])
			copy(dAtA[i:], m.SnapshotPath[iNdEx])
			i = encodeVarintTreechange(dAtA, i, uint64(len(m.SnapshotPath[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Changes) > 0 {
		for iNdEx := len(m.Changes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Changes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTreechange(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Heads) > 0 {
		for iNdEx := len(m.Heads) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Heads[iNdEx])
			copy(dAtA[i:], m.Heads[iNdEx])
			i = encodeVarintTreechange(dAtA, i, uint64(len(m.Heads[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *TreeErrorResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TreeErrorResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TreeErrorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ErrCode != 0 {
		i = encodeVarintTreechange(dAtA, i, uint64(m.ErrCode))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Error) > 0 {
		i -= len(m.Error)
		copy(dAtA[i:], m.Error)
		i = encodeVarintTreechange(dAtA, i, uint64(len(m.Error)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TreeChangeInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TreeChangeInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func encodeVarintTreechange(dAtA []byte, offset int, v uint64) int {
	offset -= sovTreechange(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *RootChange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AclHeadId)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	l = len(m.SpaceId)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	l = len(m.ChangeType)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	if m.Timestamp != 0 {
		n += 1 + sovTreechange(uint64(m.Timestamp))
	}
	l = len(m.Seed)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	l = len(m.Identity)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	l = len(m.ChangePayload)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	if m.IsDerived {
		n += 2
	}
	return n
}

func (m *TreeChange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.TreeHeadIds) > 0 {
		for _, s := range m.TreeHeadIds {
			l = len(s)
			n += 1 + l + sovTreechange(uint64(l))
		}
	}
	l = len(m.AclHeadId)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	l = len(m.SnapshotBaseId)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	l = len(m.ChangesData)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	l = len(m.ReadKeyId)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	if m.Timestamp != 0 {
		n += 1 + sovTreechange(uint64(m.Timestamp))
	}
	l = len(m.Identity)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	if m.IsSnapshot {
		n += 2
	}
	l = len(m.DataType)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	return n
}

func (m *NoDataTreeChange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.TreeHeadIds) > 0 {
		for _, s := range m.TreeHeadIds {
			l = len(s)
			n += 1 + l + sovTreechange(uint64(l))
		}
	}
	l = len(m.AclHeadId)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	l = len(m.SnapshotBaseId)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	l = len(m.ReadKeyId)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	if m.Timestamp != 0 {
		n += 1 + sovTreechange(uint64(m.Timestamp))
	}
	l = len(m.Identity)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	if m.IsSnapshot {
		n += 2
	}
	l = len(m.DataType)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	return n
}

func (m *ReducedTreeChange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.TreeHeadIds) > 0 {
		for _, s := range m.TreeHeadIds {
			l = len(s)
			n += 1 + l + sovTreechange(uint64(l))
		}
	}
	return n
}

func (m *RawTreeChange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	return n
}

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

func (m *TreeSyncMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Content != nil {
		l = m.Content.Size()
		n += 1 + l + sovTreechange(uint64(l))
	}
	if m.RootChange != nil {
		l = m.RootChange.Size()
		n += 1 + l + sovTreechange(uint64(l))
	}
	return n
}

func (m *TreeSyncContentValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != nil {
		n += m.Value.Size()
	}
	return n
}

func (m *TreeSyncContentValue_HeadUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.HeadUpdate != nil {
		l = m.HeadUpdate.Size()
		n += 1 + l + sovTreechange(uint64(l))
	}
	return n
}
func (m *TreeSyncContentValue_FullSyncRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FullSyncRequest != nil {
		l = m.FullSyncRequest.Size()
		n += 1 + l + sovTreechange(uint64(l))
	}
	return n
}
func (m *TreeSyncContentValue_FullSyncResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FullSyncResponse != nil {
		l = m.FullSyncResponse.Size()
		n += 1 + l + sovTreechange(uint64(l))
	}
	return n
}
func (m *TreeSyncContentValue_ErrorResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ErrorResponse != nil {
		l = m.ErrorResponse.Size()
		n += 1 + l + sovTreechange(uint64(l))
	}
	return n
}
func (m *TreeHeadUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Heads) > 0 {
		for _, s := range m.Heads {
			l = len(s)
			n += 1 + l + sovTreechange(uint64(l))
		}
	}
	if len(m.Changes) > 0 {
		for _, e := range m.Changes {
			l = e.Size()
			n += 1 + l + sovTreechange(uint64(l))
		}
	}
	if len(m.SnapshotPath) > 0 {
		for _, s := range m.SnapshotPath {
			l = len(s)
			n += 1 + l + sovTreechange(uint64(l))
		}
	}
	return n
}

func (m *TreeFullSyncRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Heads) > 0 {
		for _, s := range m.Heads {
			l = len(s)
			n += 1 + l + sovTreechange(uint64(l))
		}
	}
	if len(m.Changes) > 0 {
		for _, e := range m.Changes {
			l = e.Size()
			n += 1 + l + sovTreechange(uint64(l))
		}
	}
	if len(m.SnapshotPath) > 0 {
		for _, s := range m.SnapshotPath {
			l = len(s)
			n += 1 + l + sovTreechange(uint64(l))
		}
	}
	return n
}

func (m *TreeFullSyncResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Heads) > 0 {
		for _, s := range m.Heads {
			l = len(s)
			n += 1 + l + sovTreechange(uint64(l))
		}
	}
	if len(m.Changes) > 0 {
		for _, e := range m.Changes {
			l = e.Size()
			n += 1 + l + sovTreechange(uint64(l))
		}
	}
	if len(m.SnapshotPath) > 0 {
		for _, s := range m.SnapshotPath {
			l = len(s)
			n += 1 + l + sovTreechange(uint64(l))
		}
	}
	return n
}

func (m *TreeErrorResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	if m.ErrCode != 0 {
		n += 1 + sovTreechange(uint64(m.ErrCode))
	}
	return n
}

func (m *TreeChangeInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChangeType)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	l = len(m.ChangePayload)
	if l > 0 {
		n += 1 + l + sovTreechange(uint64(l))
	}
	return n
}

func sovTreechange(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTreechange(x uint64) (n int) {
	return sovTreechange(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *RootChange) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTreechange
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RootChange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RootChange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AclHeadId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AclHeadId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChangeType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seed", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Seed = append(m.Seed[:0], dAtA[iNdEx:postIndex]...)
			if m.Seed == nil {
				m.Seed = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Identity = append(m.Identity[:0], dAtA[iNdEx:postIndex]...)
			if m.Identity == nil {
				m.Identity = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangePayload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChangePayload = append(m.ChangePayload[:0], dAtA[iNdEx:postIndex]...)
			if m.ChangePayload == nil {
				m.ChangePayload = []byte{}
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsDerived", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsDerived = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTreechange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTreechange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TreeChange) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTreechange
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TreeChange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TreeChange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TreeHeadIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TreeHeadIds = append(m.TreeHeadIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AclHeadId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AclHeadId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SnapshotBaseId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SnapshotBaseId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangesData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChangesData = append(m.ChangesData[:0], dAtA[iNdEx:postIndex]...)
			if m.ChangesData == nil {
				m.ChangesData = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadKeyId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReadKeyId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Identity = append(m.Identity[:0], dAtA[iNdEx:postIndex]...)
			if m.Identity == nil {
				m.Identity = []byte{}
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsSnapshot", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsSnapshot = bool(v != 0)
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DataType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTreechange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTreechange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NoDataTreeChange) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTreechange
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NoDataTreeChange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NoDataTreeChange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TreeHeadIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TreeHeadIds = append(m.TreeHeadIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AclHeadId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AclHeadId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SnapshotBaseId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SnapshotBaseId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadKeyId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReadKeyId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Identity = append(m.Identity[:0], dAtA[iNdEx:postIndex]...)
			if m.Identity == nil {
				m.Identity = []byte{}
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsSnapshot", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsSnapshot = bool(v != 0)
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DataType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTreechange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTreechange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReducedTreeChange) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTreechange
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ReducedTreeChange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReducedTreeChange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TreeHeadIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TreeHeadIds = append(m.TreeHeadIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTreechange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTreechange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RawTreeChange) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTreechange
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RawTreeChange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RawTreeChange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTreechange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTreechange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RawTreeChangeWithId) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTreechange
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RawTreeChangeWithId: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RawTreeChangeWithId: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawChange", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RawChange = append(m.RawChange[:0], dAtA[iNdEx:postIndex]...)
			if m.RawChange == nil {
				m.RawChange = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTreechange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTreechange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TreeSyncMessage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTreechange
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TreeSyncMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TreeSyncMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Content == nil {
				m.Content = &TreeSyncContentValue{}
			}
			if err := m.Content.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RootChange", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RootChange == nil {
				m.RootChange = &RawTreeChangeWithId{}
			}
			if err := m.RootChange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTreechange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTreechange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TreeSyncContentValue) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTreechange
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TreeSyncContentValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TreeSyncContentValue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeadUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &TreeHeadUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &TreeSyncContentValue_HeadUpdate{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FullSyncRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &TreeFullSyncRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &TreeSyncContentValue_FullSyncRequest{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FullSyncResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &TreeFullSyncResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &TreeSyncContentValue_FullSyncResponse{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrorResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &TreeErrorResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &TreeSyncContentValue_ErrorResponse{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTreechange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTreechange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TreeHeadUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTreechange
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TreeHeadUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TreeHeadUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Heads", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Heads = append(m.Heads, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Changes = append(m.Changes, &RawTreeChangeWithId{})
			if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SnapshotPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SnapshotPath = append(m.SnapshotPath, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTreechange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTreechange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TreeFullSyncRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTreechange
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TreeFullSyncRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TreeFullSyncRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Heads", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Heads = append(m.Heads, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Changes = append(m.Changes, &RawTreeChangeWithId{})
			if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SnapshotPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SnapshotPath = append(m.SnapshotPath, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTreechange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTreechange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TreeFullSyncResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTreechange
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TreeFullSyncResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TreeFullSyncResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Heads", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Heads = append(m.Heads, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Changes = append(m.Changes, &RawTreeChangeWithId{})
			if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SnapshotPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SnapshotPath = append(m.SnapshotPath, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTreechange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTreechange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TreeErrorResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTreechange
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TreeErrorResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TreeErrorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Error = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrCode", wireType)
			}
			m.ErrCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ErrCode |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTreechange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTreechange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TreeChangeInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTreechange
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TreeChangeInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TreeChangeInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChangeType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangePayload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTreechange
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTreechange
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChangePayload = append(m.ChangePayload[:0], dAtA[iNdEx:postIndex]...)
			if m.ChangePayload == nil {
				m.ChangePayload = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTreechange(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTreechange
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTreechange(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowTreechange
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTreechange
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthTreechange
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTreechange
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTreechange
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthTreechange        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTreechange          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTreechange = fmt.Errorf("proto: unexpected end of group")
)