// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: pb/protos/changes.proto

package pb

import (
	fmt "fmt"
	model "github.com/anyproto/anytype-heart/pkg/lib/pb/model"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	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 ModifyOp int32

const (
	ModifyOp_Set      ModifyOp = 0
	ModifyOp_Unset    ModifyOp = 1
	ModifyOp_Inc      ModifyOp = 2
	ModifyOp_AddToSet ModifyOp = 3
	ModifyOp_Pull     ModifyOp = 4
)

var ModifyOp_name = map[int32]string{
	0: "Set",
	1: "Unset",
	2: "Inc",
	3: "AddToSet",
	4: "Pull",
}

var ModifyOp_value = map[string]int32{
	"Set":      0,
	"Unset":    1,
	"Inc":      2,
	"AddToSet": 3,
	"Pull":     4,
}

func (x ModifyOp) String() string {
	return proto.EnumName(ModifyOp_name, int32(x))
}

func (ModifyOp) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2b02bba284ea1e46, []int{0}
}

// the element of change tree used to store and internal apply smartBlock history
type Change struct {
	// set of actions to apply
	Content []*ChangeContent `protobuf:"bytes,3,rep,name=content,proto3" json:"content,omitempty"`
	// snapshot - when not null, the Content will be ignored
	Snapshot *ChangeSnapshot `protobuf:"bytes,4,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
	// file keys related to changes content
	FileKeys []*ChangeFileKeys `protobuf:"bytes,6,rep,name=fileKeys,proto3" json:"fileKeys,omitempty"`
	// creation timestamp
	Timestamp int64 `protobuf:"varint,7,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// version of business logic
	Version uint32 `protobuf:"varint,8,opt,name=version,proto3" json:"version,omitempty"`
}

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

var xxx_messageInfo_Change proto.InternalMessageInfo

func (m *Change) GetContent() []*ChangeContent {
	if m != nil {
		return m.Content
	}
	return nil
}

func (m *Change) GetSnapshot() *ChangeSnapshot {
	if m != nil {
		return m.Snapshot
	}
	return nil
}

func (m *Change) GetFileKeys() []*ChangeFileKeys {
	if m != nil {
		return m.FileKeys
	}
	return nil
}

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

func (m *Change) GetVersion() uint32 {
	if m != nil {
		return m.Version
	}
	return 0
}

type ChangeSnapshot struct {
	// logId -> lastChangeId
	LogHeads map[string]string `protobuf:"bytes,1,rep,name=logHeads,proto3" json:"logHeads,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// snapshot data
	Data *model.SmartBlockSnapshotBase `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// all file keys related to doc
	FileKeys []*ChangeFileKeys `protobuf:"bytes,3,rep,name=fileKeys,proto3" json:"fileKeys,omitempty"`
}

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

var xxx_messageInfo_ChangeSnapshot proto.InternalMessageInfo

func (m *ChangeSnapshot) GetLogHeads() map[string]string {
	if m != nil {
		return m.LogHeads
	}
	return nil
}

func (m *ChangeSnapshot) GetData() *model.SmartBlockSnapshotBase {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *ChangeSnapshot) GetFileKeys() []*ChangeFileKeys {
	if m != nil {
		return m.FileKeys
	}
	return nil
}

type ChangeFileKeys struct {
	Hash string            `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Keys map[string]string `protobuf:"bytes,2,rep,name=keys,proto3" json:"keys,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_ChangeFileKeys proto.InternalMessageInfo

func (m *ChangeFileKeys) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

func (m *ChangeFileKeys) GetKeys() map[string]string {
	if m != nil {
		return m.Keys
	}
	return nil
}

type ChangeContent struct {
	// Types that are valid to be assigned to Value:
	//	*ChangeContentValueOfBlockCreate
	//	*ChangeContentValueOfBlockUpdate
	//	*ChangeContentValueOfBlockRemove
	//	*ChangeContentValueOfBlockMove
	//	*ChangeContentValueOfBlockDuplicate
	//	*ChangeContentValueOfRelationAdd
	//	*ChangeContentValueOfRelationRemove
	//	*ChangeContentValueOfDetailsSet
	//	*ChangeContentValueOfDetailsUnset
	//	*ChangeContentValueOfObjectTypeAdd
	//	*ChangeContentValueOfObjectTypeRemove
	//	*ChangeContentValueOfStoreKeySet
	//	*ChangeContentValueOfStoreKeyUnset
	//	*ChangeContentValueOfStoreSliceUpdate
	//	*ChangeContentValueOfOriginalCreatedTimestampSet
	//	*ChangeContentValueOfSetFileInfo
	//	*ChangeContentValueOfNotificationCreate
	//	*ChangeContentValueOfNotificationUpdate
	//	*ChangeContentValueOfDeviceAdd
	//	*ChangeContentValueOfDeviceUpdate
	Value IsChangeContentValue `protobuf_oneof:"value"`
}

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

var xxx_messageInfo_ChangeContent proto.InternalMessageInfo

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

type ChangeContentValueOfBlockCreate struct {
	BlockCreate *ChangeBlockCreate `protobuf:"bytes,1,opt,name=blockCreate,proto3,oneof" json:"blockCreate,omitempty"`
}
type ChangeContentValueOfBlockUpdate struct {
	BlockUpdate *ChangeBlockUpdate `protobuf:"bytes,2,opt,name=blockUpdate,proto3,oneof" json:"blockUpdate,omitempty"`
}
type ChangeContentValueOfBlockRemove struct {
	BlockRemove *ChangeBlockRemove `protobuf:"bytes,3,opt,name=blockRemove,proto3,oneof" json:"blockRemove,omitempty"`
}
type ChangeContentValueOfBlockMove struct {
	BlockMove *ChangeBlockMove `protobuf:"bytes,4,opt,name=blockMove,proto3,oneof" json:"blockMove,omitempty"`
}
type ChangeContentValueOfBlockDuplicate struct {
	BlockDuplicate *ChangeBlockDuplicate `protobuf:"bytes,5,opt,name=blockDuplicate,proto3,oneof" json:"blockDuplicate,omitempty"`
}
type ChangeContentValueOfRelationAdd struct {
	RelationAdd *ChangeRelationAdd `protobuf:"bytes,50,opt,name=relationAdd,proto3,oneof" json:"relationAdd,omitempty"`
}
type ChangeContentValueOfRelationRemove struct {
	RelationRemove *ChangeRelationRemove `protobuf:"bytes,51,opt,name=relationRemove,proto3,oneof" json:"relationRemove,omitempty"`
}
type ChangeContentValueOfDetailsSet struct {
	DetailsSet *ChangeDetailsSet `protobuf:"bytes,100,opt,name=detailsSet,proto3,oneof" json:"detailsSet,omitempty"`
}
type ChangeContentValueOfDetailsUnset struct {
	DetailsUnset *ChangeDetailsUnset `protobuf:"bytes,101,opt,name=detailsUnset,proto3,oneof" json:"detailsUnset,omitempty"`
}
type ChangeContentValueOfObjectTypeAdd struct {
	ObjectTypeAdd *ChangeObjectTypeAdd `protobuf:"bytes,105,opt,name=objectTypeAdd,proto3,oneof" json:"objectTypeAdd,omitempty"`
}
type ChangeContentValueOfObjectTypeRemove struct {
	ObjectTypeRemove *ChangeObjectTypeRemove `protobuf:"bytes,106,opt,name=objectTypeRemove,proto3,oneof" json:"objectTypeRemove,omitempty"`
}
type ChangeContentValueOfStoreKeySet struct {
	StoreKeySet *ChangeStoreKeySet `protobuf:"bytes,107,opt,name=storeKeySet,proto3,oneof" json:"storeKeySet,omitempty"`
}
type ChangeContentValueOfStoreKeyUnset struct {
	StoreKeyUnset *ChangeStoreKeyUnset `protobuf:"bytes,108,opt,name=storeKeyUnset,proto3,oneof" json:"storeKeyUnset,omitempty"`
}
type ChangeContentValueOfStoreSliceUpdate struct {
	StoreSliceUpdate *ChangeStoreSliceUpdate `protobuf:"bytes,109,opt,name=storeSliceUpdate,proto3,oneof" json:"storeSliceUpdate,omitempty"`
}
type ChangeContentValueOfOriginalCreatedTimestampSet struct {
	OriginalCreatedTimestampSet *ChangeOriginalCreatedTimestampSet `protobuf:"bytes,110,opt,name=originalCreatedTimestampSet,proto3,oneof" json:"originalCreatedTimestampSet,omitempty"`
}
type ChangeContentValueOfSetFileInfo struct {
	SetFileInfo *ChangeSetFileInfo `protobuf:"bytes,111,opt,name=setFileInfo,proto3,oneof" json:"setFileInfo,omitempty"`
}
type ChangeContentValueOfNotificationCreate struct {
	NotificationCreate *ChangeNotificationCreate `protobuf:"bytes,112,opt,name=notificationCreate,proto3,oneof" json:"notificationCreate,omitempty"`
}
type ChangeContentValueOfNotificationUpdate struct {
	NotificationUpdate *ChangeNotificationUpdate `protobuf:"bytes,113,opt,name=notificationUpdate,proto3,oneof" json:"notificationUpdate,omitempty"`
}
type ChangeContentValueOfDeviceAdd struct {
	DeviceAdd *ChangeDeviceAdd `protobuf:"bytes,114,opt,name=deviceAdd,proto3,oneof" json:"deviceAdd,omitempty"`
}
type ChangeContentValueOfDeviceUpdate struct {
	DeviceUpdate *ChangeDeviceUpdate `protobuf:"bytes,115,opt,name=deviceUpdate,proto3,oneof" json:"deviceUpdate,omitempty"`
}

func (*ChangeContentValueOfBlockCreate) IsChangeContentValue()                 {}
func (*ChangeContentValueOfBlockUpdate) IsChangeContentValue()                 {}
func (*ChangeContentValueOfBlockRemove) IsChangeContentValue()                 {}
func (*ChangeContentValueOfBlockMove) IsChangeContentValue()                   {}
func (*ChangeContentValueOfBlockDuplicate) IsChangeContentValue()              {}
func (*ChangeContentValueOfRelationAdd) IsChangeContentValue()                 {}
func (*ChangeContentValueOfRelationRemove) IsChangeContentValue()              {}
func (*ChangeContentValueOfDetailsSet) IsChangeContentValue()                  {}
func (*ChangeContentValueOfDetailsUnset) IsChangeContentValue()                {}
func (*ChangeContentValueOfObjectTypeAdd) IsChangeContentValue()               {}
func (*ChangeContentValueOfObjectTypeRemove) IsChangeContentValue()            {}
func (*ChangeContentValueOfStoreKeySet) IsChangeContentValue()                 {}
func (*ChangeContentValueOfStoreKeyUnset) IsChangeContentValue()               {}
func (*ChangeContentValueOfStoreSliceUpdate) IsChangeContentValue()            {}
func (*ChangeContentValueOfOriginalCreatedTimestampSet) IsChangeContentValue() {}
func (*ChangeContentValueOfSetFileInfo) IsChangeContentValue()                 {}
func (*ChangeContentValueOfNotificationCreate) IsChangeContentValue()          {}
func (*ChangeContentValueOfNotificationUpdate) IsChangeContentValue()          {}
func (*ChangeContentValueOfDeviceAdd) IsChangeContentValue()                   {}
func (*ChangeContentValueOfDeviceUpdate) IsChangeContentValue()                {}

func (m *ChangeContent) GetValue() IsChangeContentValue {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *ChangeContent) GetBlockCreate() *ChangeBlockCreate {
	if x, ok := m.GetValue().(*ChangeContentValueOfBlockCreate); ok {
		return x.BlockCreate
	}
	return nil
}

func (m *ChangeContent) GetBlockUpdate() *ChangeBlockUpdate {
	if x, ok := m.GetValue().(*ChangeContentValueOfBlockUpdate); ok {
		return x.BlockUpdate
	}
	return nil
}

func (m *ChangeContent) GetBlockRemove() *ChangeBlockRemove {
	if x, ok := m.GetValue().(*ChangeContentValueOfBlockRemove); ok {
		return x.BlockRemove
	}
	return nil
}

func (m *ChangeContent) GetBlockMove() *ChangeBlockMove {
	if x, ok := m.GetValue().(*ChangeContentValueOfBlockMove); ok {
		return x.BlockMove
	}
	return nil
}

func (m *ChangeContent) GetBlockDuplicate() *ChangeBlockDuplicate {
	if x, ok := m.GetValue().(*ChangeContentValueOfBlockDuplicate); ok {
		return x.BlockDuplicate
	}
	return nil
}

func (m *ChangeContent) GetRelationAdd() *ChangeRelationAdd {
	if x, ok := m.GetValue().(*ChangeContentValueOfRelationAdd); ok {
		return x.RelationAdd
	}
	return nil
}

func (m *ChangeContent) GetRelationRemove() *ChangeRelationRemove {
	if x, ok := m.GetValue().(*ChangeContentValueOfRelationRemove); ok {
		return x.RelationRemove
	}
	return nil
}

func (m *ChangeContent) GetDetailsSet() *ChangeDetailsSet {
	if x, ok := m.GetValue().(*ChangeContentValueOfDetailsSet); ok {
		return x.DetailsSet
	}
	return nil
}

func (m *ChangeContent) GetDetailsUnset() *ChangeDetailsUnset {
	if x, ok := m.GetValue().(*ChangeContentValueOfDetailsUnset); ok {
		return x.DetailsUnset
	}
	return nil
}

func (m *ChangeContent) GetObjectTypeAdd() *ChangeObjectTypeAdd {
	if x, ok := m.GetValue().(*ChangeContentValueOfObjectTypeAdd); ok {
		return x.ObjectTypeAdd
	}
	return nil
}

func (m *ChangeContent) GetObjectTypeRemove() *ChangeObjectTypeRemove {
	if x, ok := m.GetValue().(*ChangeContentValueOfObjectTypeRemove); ok {
		return x.ObjectTypeRemove
	}
	return nil
}

func (m *ChangeContent) GetStoreKeySet() *ChangeStoreKeySet {
	if x, ok := m.GetValue().(*ChangeContentValueOfStoreKeySet); ok {
		return x.StoreKeySet
	}
	return nil
}

func (m *ChangeContent) GetStoreKeyUnset() *ChangeStoreKeyUnset {
	if x, ok := m.GetValue().(*ChangeContentValueOfStoreKeyUnset); ok {
		return x.StoreKeyUnset
	}
	return nil
}

func (m *ChangeContent) GetStoreSliceUpdate() *ChangeStoreSliceUpdate {
	if x, ok := m.GetValue().(*ChangeContentValueOfStoreSliceUpdate); ok {
		return x.StoreSliceUpdate
	}
	return nil
}

func (m *ChangeContent) GetOriginalCreatedTimestampSet() *ChangeOriginalCreatedTimestampSet {
	if x, ok := m.GetValue().(*ChangeContentValueOfOriginalCreatedTimestampSet); ok {
		return x.OriginalCreatedTimestampSet
	}
	return nil
}

func (m *ChangeContent) GetSetFileInfo() *ChangeSetFileInfo {
	if x, ok := m.GetValue().(*ChangeContentValueOfSetFileInfo); ok {
		return x.SetFileInfo
	}
	return nil
}

func (m *ChangeContent) GetNotificationCreate() *ChangeNotificationCreate {
	if x, ok := m.GetValue().(*ChangeContentValueOfNotificationCreate); ok {
		return x.NotificationCreate
	}
	return nil
}

func (m *ChangeContent) GetNotificationUpdate() *ChangeNotificationUpdate {
	if x, ok := m.GetValue().(*ChangeContentValueOfNotificationUpdate); ok {
		return x.NotificationUpdate
	}
	return nil
}

func (m *ChangeContent) GetDeviceAdd() *ChangeDeviceAdd {
	if x, ok := m.GetValue().(*ChangeContentValueOfDeviceAdd); ok {
		return x.DeviceAdd
	}
	return nil
}

func (m *ChangeContent) GetDeviceUpdate() *ChangeDeviceUpdate {
	if x, ok := m.GetValue().(*ChangeContentValueOfDeviceUpdate); ok {
		return x.DeviceUpdate
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ChangeContent) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ChangeContentValueOfBlockCreate)(nil),
		(*ChangeContentValueOfBlockUpdate)(nil),
		(*ChangeContentValueOfBlockRemove)(nil),
		(*ChangeContentValueOfBlockMove)(nil),
		(*ChangeContentValueOfBlockDuplicate)(nil),
		(*ChangeContentValueOfRelationAdd)(nil),
		(*ChangeContentValueOfRelationRemove)(nil),
		(*ChangeContentValueOfDetailsSet)(nil),
		(*ChangeContentValueOfDetailsUnset)(nil),
		(*ChangeContentValueOfObjectTypeAdd)(nil),
		(*ChangeContentValueOfObjectTypeRemove)(nil),
		(*ChangeContentValueOfStoreKeySet)(nil),
		(*ChangeContentValueOfStoreKeyUnset)(nil),
		(*ChangeContentValueOfStoreSliceUpdate)(nil),
		(*ChangeContentValueOfOriginalCreatedTimestampSet)(nil),
		(*ChangeContentValueOfSetFileInfo)(nil),
		(*ChangeContentValueOfNotificationCreate)(nil),
		(*ChangeContentValueOfNotificationUpdate)(nil),
		(*ChangeContentValueOfDeviceAdd)(nil),
		(*ChangeContentValueOfDeviceUpdate)(nil),
	}
}

type ChangeBlockCreate struct {
	TargetId string              `protobuf:"bytes,1,opt,name=targetId,proto3" json:"targetId,omitempty"`
	Position model.BlockPosition `protobuf:"varint,2,opt,name=position,proto3,enum=anytype.model.BlockPosition" json:"position,omitempty"`
	Blocks   []*model.Block      `protobuf:"bytes,3,rep,name=blocks,proto3" json:"blocks,omitempty"`
}

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

var xxx_messageInfo_ChangeBlockCreate proto.InternalMessageInfo

func (m *ChangeBlockCreate) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *ChangeBlockCreate) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

func (m *ChangeBlockCreate) GetBlocks() []*model.Block {
	if m != nil {
		return m.Blocks
	}
	return nil
}

type ChangeBlockUpdate struct {
	Events []*EventMessage `protobuf:"bytes,2,rep,name=events,proto3" json:"events,omitempty"`
}

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

var xxx_messageInfo_ChangeBlockUpdate proto.InternalMessageInfo

func (m *ChangeBlockUpdate) GetEvents() []*EventMessage {
	if m != nil {
		return m.Events
	}
	return nil
}

type ChangeBlockRemove struct {
	Ids []string `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
}

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

var xxx_messageInfo_ChangeBlockRemove proto.InternalMessageInfo

func (m *ChangeBlockRemove) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

type ChangeBlockMove struct {
	TargetId string              `protobuf:"bytes,1,opt,name=targetId,proto3" json:"targetId,omitempty"`
	Position model.BlockPosition `protobuf:"varint,2,opt,name=position,proto3,enum=anytype.model.BlockPosition" json:"position,omitempty"`
	Ids      []string            `protobuf:"bytes,3,rep,name=ids,proto3" json:"ids,omitempty"`
}

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

var xxx_messageInfo_ChangeBlockMove proto.InternalMessageInfo

func (m *ChangeBlockMove) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *ChangeBlockMove) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

func (m *ChangeBlockMove) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

type ChangeBlockDuplicate struct {
	TargetId string              `protobuf:"bytes,1,opt,name=targetId,proto3" json:"targetId,omitempty"`
	Position model.BlockPosition `protobuf:"varint,2,opt,name=position,proto3,enum=anytype.model.BlockPosition" json:"position,omitempty"`
	Ids      []string            `protobuf:"bytes,3,rep,name=ids,proto3" json:"ids,omitempty"`
}

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

var xxx_messageInfo_ChangeBlockDuplicate proto.InternalMessageInfo

func (m *ChangeBlockDuplicate) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *ChangeBlockDuplicate) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

func (m *ChangeBlockDuplicate) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

type ChangeDetailsSet struct {
	Key   string       `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value *types.Value `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_ChangeDetailsSet proto.InternalMessageInfo

func (m *ChangeDetailsSet) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *ChangeDetailsSet) GetValue() *types.Value {
	if m != nil {
		return m.Value
	}
	return nil
}

type ChangeDetailsUnset struct {
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
}

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

var xxx_messageInfo_ChangeDetailsUnset proto.InternalMessageInfo

func (m *ChangeDetailsUnset) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

type ChangeRelationAdd struct {
	RelationLinks []*model.RelationLink `protobuf:"bytes,1,rep,name=relationLinks,proto3" json:"relationLinks,omitempty"`
}

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

var xxx_messageInfo_ChangeRelationAdd proto.InternalMessageInfo

func (m *ChangeRelationAdd) GetRelationLinks() []*model.RelationLink {
	if m != nil {
		return m.RelationLinks
	}
	return nil
}

type ChangeRelationRemove struct {
	RelationKey []string `protobuf:"bytes,1,rep,name=relationKey,proto3" json:"relationKey,omitempty"`
}

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

var xxx_messageInfo_ChangeRelationRemove proto.InternalMessageInfo

func (m *ChangeRelationRemove) GetRelationKey() []string {
	if m != nil {
		return m.RelationKey
	}
	return nil
}

type ChangeObjectTypeAdd struct {
	Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
	Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
}

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

var xxx_messageInfo_ChangeObjectTypeAdd proto.InternalMessageInfo

func (m *ChangeObjectTypeAdd) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

func (m *ChangeObjectTypeAdd) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

type ChangeObjectTypeRemove struct {
	Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
	Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
}

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

var xxx_messageInfo_ChangeObjectTypeRemove proto.InternalMessageInfo

func (m *ChangeObjectTypeRemove) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

func (m *ChangeObjectTypeRemove) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

type ChangeStoreKeySet struct {
	Path  []string     `protobuf:"bytes,1,rep,name=path,proto3" json:"path,omitempty"`
	Value *types.Value `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_ChangeStoreKeySet proto.InternalMessageInfo

func (m *ChangeStoreKeySet) GetPath() []string {
	if m != nil {
		return m.Path
	}
	return nil
}

func (m *ChangeStoreKeySet) GetValue() *types.Value {
	if m != nil {
		return m.Value
	}
	return nil
}

type ChangeStoreKeyUnset struct {
	Path []string `protobuf:"bytes,1,rep,name=path,proto3" json:"path,omitempty"`
}

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

var xxx_messageInfo_ChangeStoreKeyUnset proto.InternalMessageInfo

func (m *ChangeStoreKeyUnset) GetPath() []string {
	if m != nil {
		return m.Path
	}
	return nil
}

type ChangeStoreSliceUpdate struct {
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// Types that are valid to be assigned to Operation:
	//	*ChangeStoreSliceUpdateOperationOfAdd
	//	*ChangeStoreSliceUpdateOperationOfRemove
	//	*ChangeStoreSliceUpdateOperationOfMove
	Operation IsChangeStoreSliceUpdateOperation `protobuf_oneof:"operation"`
}

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

var xxx_messageInfo_ChangeStoreSliceUpdate proto.InternalMessageInfo

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

type ChangeStoreSliceUpdateOperationOfAdd struct {
	Add *ChangeStoreSliceUpdateAdd `protobuf:"bytes,2,opt,name=add,proto3,oneof" json:"add,omitempty"`
}
type ChangeStoreSliceUpdateOperationOfRemove struct {
	Remove *ChangeStoreSliceUpdateRemove `protobuf:"bytes,3,opt,name=remove,proto3,oneof" json:"remove,omitempty"`
}
type ChangeStoreSliceUpdateOperationOfMove struct {
	Move *ChangeStoreSliceUpdateMove `protobuf:"bytes,4,opt,name=move,proto3,oneof" json:"move,omitempty"`
}

func (*ChangeStoreSliceUpdateOperationOfAdd) IsChangeStoreSliceUpdateOperation()    {}
func (*ChangeStoreSliceUpdateOperationOfRemove) IsChangeStoreSliceUpdateOperation() {}
func (*ChangeStoreSliceUpdateOperationOfMove) IsChangeStoreSliceUpdateOperation()   {}

func (m *ChangeStoreSliceUpdate) GetOperation() IsChangeStoreSliceUpdateOperation {
	if m != nil {
		return m.Operation
	}
	return nil
}

func (m *ChangeStoreSliceUpdate) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *ChangeStoreSliceUpdate) GetAdd() *ChangeStoreSliceUpdateAdd {
	if x, ok := m.GetOperation().(*ChangeStoreSliceUpdateOperationOfAdd); ok {
		return x.Add
	}
	return nil
}

func (m *ChangeStoreSliceUpdate) GetRemove() *ChangeStoreSliceUpdateRemove {
	if x, ok := m.GetOperation().(*ChangeStoreSliceUpdateOperationOfRemove); ok {
		return x.Remove
	}
	return nil
}

func (m *ChangeStoreSliceUpdate) GetMove() *ChangeStoreSliceUpdateMove {
	if x, ok := m.GetOperation().(*ChangeStoreSliceUpdateOperationOfMove); ok {
		return x.Move
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ChangeStoreSliceUpdate) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ChangeStoreSliceUpdateOperationOfAdd)(nil),
		(*ChangeStoreSliceUpdateOperationOfRemove)(nil),
		(*ChangeStoreSliceUpdateOperationOfMove)(nil),
	}
}

type ChangeStoreSliceUpdateAdd struct {
	AfterId string   `protobuf:"bytes,1,opt,name=afterId,proto3" json:"afterId,omitempty"`
	Ids     []string `protobuf:"bytes,2,rep,name=ids,proto3" json:"ids,omitempty"`
}

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

var xxx_messageInfo_ChangeStoreSliceUpdateAdd proto.InternalMessageInfo

func (m *ChangeStoreSliceUpdateAdd) GetAfterId() string {
	if m != nil {
		return m.AfterId
	}
	return ""
}

func (m *ChangeStoreSliceUpdateAdd) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

type ChangeStoreSliceUpdateRemove struct {
	Ids []string `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
}

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

var xxx_messageInfo_ChangeStoreSliceUpdateRemove proto.InternalMessageInfo

func (m *ChangeStoreSliceUpdateRemove) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

type ChangeStoreSliceUpdateMove struct {
	AfterId string   `protobuf:"bytes,1,opt,name=afterId,proto3" json:"afterId,omitempty"`
	Ids     []string `protobuf:"bytes,2,rep,name=ids,proto3" json:"ids,omitempty"`
}

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

var xxx_messageInfo_ChangeStoreSliceUpdateMove proto.InternalMessageInfo

func (m *ChangeStoreSliceUpdateMove) GetAfterId() string {
	if m != nil {
		return m.AfterId
	}
	return ""
}

func (m *ChangeStoreSliceUpdateMove) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

type ChangeOriginalCreatedTimestampSet struct {
	Ts int64 `protobuf:"varint,1,opt,name=ts,proto3" json:"ts,omitempty"`
}

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

var xxx_messageInfo_ChangeOriginalCreatedTimestampSet proto.InternalMessageInfo

func (m *ChangeOriginalCreatedTimestampSet) GetTs() int64 {
	if m != nil {
		return m.Ts
	}
	return 0
}

type ChangeSetFileInfo struct {
	FileInfo *model.FileInfo `protobuf:"bytes,1,opt,name=fileInfo,proto3" json:"fileInfo,omitempty"`
}

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

var xxx_messageInfo_ChangeSetFileInfo proto.InternalMessageInfo

func (m *ChangeSetFileInfo) GetFileInfo() *model.FileInfo {
	if m != nil {
		return m.FileInfo
	}
	return nil
}

type ChangeNotificationCreate struct {
	Notification *model.Notification `protobuf:"bytes,1,opt,name=notification,proto3" json:"notification,omitempty"`
}

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

var xxx_messageInfo_ChangeNotificationCreate proto.InternalMessageInfo

func (m *ChangeNotificationCreate) GetNotification() *model.Notification {
	if m != nil {
		return m.Notification
	}
	return nil
}

type ChangeNotificationUpdate struct {
	Id     string                   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Status model.NotificationStatus `protobuf:"varint,2,opt,name=status,proto3,enum=anytype.model.NotificationStatus" json:"status,omitempty"`
}

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

var xxx_messageInfo_ChangeNotificationUpdate proto.InternalMessageInfo

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

func (m *ChangeNotificationUpdate) GetStatus() model.NotificationStatus {
	if m != nil {
		return m.Status
	}
	return model.Notification_Created
}

type ChangeDeviceAdd struct {
	Device *model.DeviceInfo `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
}

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

var xxx_messageInfo_ChangeDeviceAdd proto.InternalMessageInfo

func (m *ChangeDeviceAdd) GetDevice() *model.DeviceInfo {
	if m != nil {
		return m.Device
	}
	return nil
}

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

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

var xxx_messageInfo_ChangeDeviceUpdate proto.InternalMessageInfo

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

func (m *ChangeDeviceUpdate) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type ChangeNoSnapshot struct {
	// set of actions to apply
	Content []*ChangeContent `protobuf:"bytes,3,rep,name=content,proto3" json:"content,omitempty"`
	// file keys related to changes content
	FileKeys []*ChangeFileKeys `protobuf:"bytes,6,rep,name=fileKeys,proto3" json:"fileKeys,omitempty"`
	// creation timestamp
	Timestamp int64 `protobuf:"varint,7,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// version of business logic
	Version uint32 `protobuf:"varint,8,opt,name=version,proto3" json:"version,omitempty"`
}

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

var xxx_messageInfo_ChangeNoSnapshot proto.InternalMessageInfo

func (m *ChangeNoSnapshot) GetContent() []*ChangeContent {
	if m != nil {
		return m.Content
	}
	return nil
}

func (m *ChangeNoSnapshot) GetFileKeys() []*ChangeFileKeys {
	if m != nil {
		return m.FileKeys
	}
	return nil
}

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

func (m *ChangeNoSnapshot) GetVersion() uint32 {
	if m != nil {
		return m.Version
	}
	return 0
}

type StoreChange struct {
	ChangeSet []*StoreChangeContent `protobuf:"bytes,1,rep,name=changeSet,proto3" json:"changeSet,omitempty"`
}

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

var xxx_messageInfo_StoreChange proto.InternalMessageInfo

func (m *StoreChange) GetChangeSet() []*StoreChangeContent {
	if m != nil {
		return m.ChangeSet
	}
	return nil
}

type StoreChangeContent struct {
	// Types that are valid to be assigned to Change:
	//	*StoreChangeContentChangeOfCreate
	//	*StoreChangeContentChangeOfModify
	//	*StoreChangeContentChangeOfDelete
	Change IsStoreChangeContentChange `protobuf_oneof:"change"`
}

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

var xxx_messageInfo_StoreChangeContent proto.InternalMessageInfo

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

type StoreChangeContentChangeOfCreate struct {
	Create *DocumentCreate `protobuf:"bytes,1,opt,name=create,proto3,oneof" json:"create,omitempty"`
}
type StoreChangeContentChangeOfModify struct {
	Modify *DocumentModify `protobuf:"bytes,2,opt,name=modify,proto3,oneof" json:"modify,omitempty"`
}
type StoreChangeContentChangeOfDelete struct {
	Delete *DocumentDelete `protobuf:"bytes,3,opt,name=delete,proto3,oneof" json:"delete,omitempty"`
}

func (*StoreChangeContentChangeOfCreate) IsStoreChangeContentChange() {}
func (*StoreChangeContentChangeOfModify) IsStoreChangeContentChange() {}
func (*StoreChangeContentChangeOfDelete) IsStoreChangeContentChange() {}

func (m *StoreChangeContent) GetChange() IsStoreChangeContentChange {
	if m != nil {
		return m.Change
	}
	return nil
}

func (m *StoreChangeContent) GetCreate() *DocumentCreate {
	if x, ok := m.GetChange().(*StoreChangeContentChangeOfCreate); ok {
		return x.Create
	}
	return nil
}

func (m *StoreChangeContent) GetModify() *DocumentModify {
	if x, ok := m.GetChange().(*StoreChangeContentChangeOfModify); ok {
		return x.Modify
	}
	return nil
}

func (m *StoreChangeContent) GetDelete() *DocumentDelete {
	if x, ok := m.GetChange().(*StoreChangeContentChangeOfDelete); ok {
		return x.Delete
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*StoreChangeContent) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*StoreChangeContentChangeOfCreate)(nil),
		(*StoreChangeContentChangeOfModify)(nil),
		(*StoreChangeContentChangeOfDelete)(nil),
	}
}

type DocumentCreate struct {
	Collection string `protobuf:"bytes,1,opt,name=collection,proto3" json:"collection,omitempty"`
	DocumentId string `protobuf:"bytes,2,opt,name=documentId,proto3" json:"documentId,omitempty"`
	// json
	Value string `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_DocumentCreate proto.InternalMessageInfo

func (m *DocumentCreate) GetCollection() string {
	if m != nil {
		return m.Collection
	}
	return ""
}

func (m *DocumentCreate) GetDocumentId() string {
	if m != nil {
		return m.DocumentId
	}
	return ""
}

func (m *DocumentCreate) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type DocumentModify struct {
	Collection string       `protobuf:"bytes,1,opt,name=collection,proto3" json:"collection,omitempty"`
	DocumentId string       `protobuf:"bytes,2,opt,name=documentId,proto3" json:"documentId,omitempty"`
	Keys       []*KeyModify `protobuf:"bytes,4,rep,name=keys,proto3" json:"keys,omitempty"`
}

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

var xxx_messageInfo_DocumentModify proto.InternalMessageInfo

func (m *DocumentModify) GetCollection() string {
	if m != nil {
		return m.Collection
	}
	return ""
}

func (m *DocumentModify) GetDocumentId() string {
	if m != nil {
		return m.DocumentId
	}
	return ""
}

func (m *DocumentModify) GetKeys() []*KeyModify {
	if m != nil {
		return m.Keys
	}
	return nil
}

type KeyModify struct {
	// key path; example: [user, email]
	KeyPath []string `protobuf:"bytes,1,rep,name=keyPath,proto3" json:"keyPath,omitempty"`
	// modify op: set, unset, inc, etc.
	ModifyOp ModifyOp `protobuf:"varint,3,opt,name=modifyOp,proto3,enum=anytype.ModifyOp" json:"modifyOp,omitempty"`
	// json value; example: '"new@email.com"'
	ModifyValue string `protobuf:"bytes,4,opt,name=modifyValue,proto3" json:"modifyValue,omitempty"`
}

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

var xxx_messageInfo_KeyModify proto.InternalMessageInfo

func (m *KeyModify) GetKeyPath() []string {
	if m != nil {
		return m.KeyPath
	}
	return nil
}

func (m *KeyModify) GetModifyOp() ModifyOp {
	if m != nil {
		return m.ModifyOp
	}
	return ModifyOp_Set
}

func (m *KeyModify) GetModifyValue() string {
	if m != nil {
		return m.ModifyValue
	}
	return ""
}

type DocumentDelete struct {
	Collection string `protobuf:"bytes,1,opt,name=collection,proto3" json:"collection,omitempty"`
	DocumentId string `protobuf:"bytes,2,opt,name=documentId,proto3" json:"documentId,omitempty"`
}

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

var xxx_messageInfo_DocumentDelete proto.InternalMessageInfo

func (m *DocumentDelete) GetCollection() string {
	if m != nil {
		return m.Collection
	}
	return ""
}

func (m *DocumentDelete) GetDocumentId() string {
	if m != nil {
		return m.DocumentId
	}
	return ""
}

func init() {
	proto.RegisterEnum("anytype.ModifyOp", ModifyOp_name, ModifyOp_value)
	proto.RegisterType((*Change)(nil), "anytype.Change")
	proto.RegisterType((*ChangeSnapshot)(nil), "anytype.Change.Snapshot")
	proto.RegisterMapType((map[string]string)(nil), "anytype.Change.Snapshot.LogHeadsEntry")
	proto.RegisterType((*ChangeFileKeys)(nil), "anytype.Change.FileKeys")
	proto.RegisterMapType((map[string]string)(nil), "anytype.Change.FileKeys.KeysEntry")
	proto.RegisterType((*ChangeContent)(nil), "anytype.Change.Content")
	proto.RegisterType((*ChangeBlockCreate)(nil), "anytype.Change.BlockCreate")
	proto.RegisterType((*ChangeBlockUpdate)(nil), "anytype.Change.BlockUpdate")
	proto.RegisterType((*ChangeBlockRemove)(nil), "anytype.Change.BlockRemove")
	proto.RegisterType((*ChangeBlockMove)(nil), "anytype.Change.BlockMove")
	proto.RegisterType((*ChangeBlockDuplicate)(nil), "anytype.Change.BlockDuplicate")
	proto.RegisterType((*ChangeDetailsSet)(nil), "anytype.Change.DetailsSet")
	proto.RegisterType((*ChangeDetailsUnset)(nil), "anytype.Change.DetailsUnset")
	proto.RegisterType((*ChangeRelationAdd)(nil), "anytype.Change.RelationAdd")
	proto.RegisterType((*ChangeRelationRemove)(nil), "anytype.Change.RelationRemove")
	proto.RegisterType((*ChangeObjectTypeAdd)(nil), "anytype.Change.ObjectTypeAdd")
	proto.RegisterType((*ChangeObjectTypeRemove)(nil), "anytype.Change.ObjectTypeRemove")
	proto.RegisterType((*ChangeStoreKeySet)(nil), "anytype.Change.StoreKeySet")
	proto.RegisterType((*ChangeStoreKeyUnset)(nil), "anytype.Change.StoreKeyUnset")
	proto.RegisterType((*ChangeStoreSliceUpdate)(nil), "anytype.Change.StoreSliceUpdate")
	proto.RegisterType((*ChangeStoreSliceUpdateAdd)(nil), "anytype.Change.StoreSliceUpdate.Add")
	proto.RegisterType((*ChangeStoreSliceUpdateRemove)(nil), "anytype.Change.StoreSliceUpdate.Remove")
	proto.RegisterType((*ChangeStoreSliceUpdateMove)(nil), "anytype.Change.StoreSliceUpdate.Move")
	proto.RegisterType((*ChangeOriginalCreatedTimestampSet)(nil), "anytype.Change.OriginalCreatedTimestampSet")
	proto.RegisterType((*ChangeSetFileInfo)(nil), "anytype.Change.SetFileInfo")
	proto.RegisterType((*ChangeNotificationCreate)(nil), "anytype.Change.NotificationCreate")
	proto.RegisterType((*ChangeNotificationUpdate)(nil), "anytype.Change.NotificationUpdate")
	proto.RegisterType((*ChangeDeviceAdd)(nil), "anytype.Change.DeviceAdd")
	proto.RegisterType((*ChangeDeviceUpdate)(nil), "anytype.Change.DeviceUpdate")
	proto.RegisterType((*ChangeNoSnapshot)(nil), "anytype.ChangeNoSnapshot")
	proto.RegisterType((*StoreChange)(nil), "anytype.StoreChange")
	proto.RegisterType((*StoreChangeContent)(nil), "anytype.StoreChangeContent")
	proto.RegisterType((*DocumentCreate)(nil), "anytype.DocumentCreate")
	proto.RegisterType((*DocumentModify)(nil), "anytype.DocumentModify")
	proto.RegisterType((*KeyModify)(nil), "anytype.KeyModify")
	proto.RegisterType((*DocumentDelete)(nil), "anytype.DocumentDelete")
}

func init() { proto.RegisterFile("pb/protos/changes.proto", fileDescriptor_2b02bba284ea1e46) }

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

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

func (m *Change) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Version != 0 {
		i = encodeVarintChanges(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x40
	}
	if m.Timestamp != 0 {
		i = encodeVarintChanges(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x38
	}
	if len(m.FileKeys) > 0 {
		for iNdEx := len(m.FileKeys) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.FileKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintChanges(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if m.Snapshot != nil {
		{
			size, err := m.Snapshot.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Content) > 0 {
		for iNdEx := len(m.Content) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Content[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintChanges(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *ChangeSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.FileKeys) > 0 {
		for iNdEx := len(m.FileKeys) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.FileKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintChanges(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Data != nil {
		{
			size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.LogHeads) > 0 {
		for k := range m.LogHeads {
			v := m.LogHeads[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintChanges(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintChanges(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintChanges(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *ChangeFileKeys) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Keys) > 0 {
		for k := range m.Keys {
			v := m.Keys[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintChanges(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintChanges(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintChanges(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintChanges(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *ChangeContentValueOfBlockMove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockMove != nil {
		{
			size, err := m.BlockMove.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *ChangeContentValueOfBlockDuplicate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeContentValueOfBlockDuplicate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockDuplicate != nil {
		{
			size, err := m.BlockDuplicate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *ChangeContentValueOfRelationAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeContentValueOfRelationAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RelationAdd != nil {
		{
			size, err := m.RelationAdd.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x92
	}
	return len(dAtA) - i, nil
}
func (m *ChangeContentValueOfRelationRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeContentValueOfRelationRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RelationRemove != nil {
		{
			size, err := m.RelationRemove.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x9a
	}
	return len(dAtA) - i, nil
}
func (m *ChangeContentValueOfDetailsSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeContentValueOfDetailsSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DetailsSet != nil {
		{
			size, err := m.DetailsSet.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xa2
	}
	return len(dAtA) - i, nil
}
func (m *ChangeContentValueOfDetailsUnset) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeContentValueOfDetailsUnset) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DetailsUnset != nil {
		{
			size, err := m.DetailsUnset.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xaa
	}
	return len(dAtA) - i, nil
}
func (m *ChangeContentValueOfObjectTypeAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeContentValueOfObjectTypeAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ObjectTypeAdd != nil {
		{
			size, err := m.ObjectTypeAdd.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xca
	}
	return len(dAtA) - i, nil
}
func (m *ChangeContentValueOfObjectTypeRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeContentValueOfObjectTypeRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ObjectTypeRemove != nil {
		{
			size, err := m.ObjectTypeRemove.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xd2
	}
	return len(dAtA) - i, nil
}
func (m *ChangeContentValueOfStoreKeySet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeContentValueOfStoreKeySet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.StoreKeySet != nil {
		{
			size, err := m.StoreKeySet.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xda
	}
	return len(dAtA) - i, nil
}
func (m *ChangeContentValueOfStoreKeyUnset) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeContentValueOfStoreKeyUnset) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.StoreKeyUnset != nil {
		{
			size, err := m.StoreKeyUnset.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xe2
	}
	return len(dAtA) - i, nil
}
func (m *ChangeContentValueOfStoreSliceUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeContentValueOfStoreSliceUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.StoreSliceUpdate != nil {
		{
			size, err := m.StoreSliceUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xea
	}
	return len(dAtA) - i, nil
}
func (m *ChangeContentValueOfOriginalCreatedTimestampSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeContentValueOfOriginalCreatedTimestampSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.OriginalCreatedTimestampSet != nil {
		{
			size, err := m.OriginalCreatedTimestampSet.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xf2
	}
	return len(dAtA) - i, nil
}
func (m *ChangeContentValueOfSetFileInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeContentValueOfSetFileInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SetFileInfo != nil {
		{
			size, err := m.SetFileInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xfa
	}
	return len(dAtA) - i, nil
}
func (m *ChangeContentValueOfNotificationCreate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeContentValueOfNotificationCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NotificationCreate != nil {
		{
			size, err := m.NotificationCreate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0x82
	}
	return len(dAtA) - i, nil
}
func (m *ChangeContentValueOfNotificationUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeContentValueOfNotificationUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NotificationUpdate != nil {
		{
			size, err := m.NotificationUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0x8a
	}
	return len(dAtA) - i, nil
}
func (m *ChangeContentValueOfDeviceAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeContentValueOfDeviceAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DeviceAdd != nil {
		{
			size, err := m.DeviceAdd.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0x92
	}
	return len(dAtA) - i, nil
}
func (m *ChangeContentValueOfDeviceUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeContentValueOfDeviceUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DeviceUpdate != nil {
		{
			size, err := m.DeviceUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0x9a
	}
	return len(dAtA) - i, nil
}
func (m *ChangeBlockCreate) 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 *ChangeBlockCreate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangeBlockCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Blocks) > 0 {
		for iNdEx := len(m.Blocks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Blocks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintChanges(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Position != 0 {
		i = encodeVarintChanges(dAtA, i, uint64(m.Position))
		i--
		dAtA[i] = 0x10
	}
	if len(m.TargetId) > 0 {
		i -= len(m.TargetId)
		copy(dAtA[i:], m.TargetId)
		i = encodeVarintChanges(dAtA, i, uint64(len(m.TargetId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ChangeBlockUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Events) > 0 {
		for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Events[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintChanges(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *ChangeBlockMove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Ids[iNdEx])
			copy(dAtA[i:], m.Ids[iNdEx])
			i = encodeVarintChanges(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Position != 0 {
		i = encodeVarintChanges(dAtA, i, uint64(m.Position))
		i--
		dAtA[i] = 0x10
	}
	if len(m.TargetId) > 0 {
		i -= len(m.TargetId)
		copy(dAtA[i:], m.TargetId)
		i = encodeVarintChanges(dAtA, i, uint64(len(m.TargetId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ChangeBlockDuplicate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Ids[iNdEx])
			copy(dAtA[i:], m.Ids[iNdEx])
			i = encodeVarintChanges(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Position != 0 {
		i = encodeVarintChanges(dAtA, i, uint64(m.Position))
		i--
		dAtA[i] = 0x10
	}
	if len(m.TargetId) > 0 {
		i -= len(m.TargetId)
		copy(dAtA[i:], m.TargetId)
		i = encodeVarintChanges(dAtA, i, uint64(len(m.TargetId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *ChangeRelationAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RelationLinks) > 0 {
		for iNdEx := len(m.RelationLinks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.RelationLinks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintChanges(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

func (m *ChangeStoreSliceUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Operation != nil {
		{
			size := m.Operation.Size()
			i -= size
			if _, err := m.Operation.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintChanges(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *ChangeStoreSliceUpdateOperationOfMove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Move != nil {
		{
			size, err := m.Move.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *ChangeStoreSliceUpdateAdd) 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 *ChangeStoreSliceUpdateAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

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

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

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

func (m *ChangeOriginalCreatedTimestampSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Ts != 0 {
		i = encodeVarintChanges(dAtA, i, uint64(m.Ts))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

func (m *ChangeNoSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Version != 0 {
		i = encodeVarintChanges(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x40
	}
	if m.Timestamp != 0 {
		i = encodeVarintChanges(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x38
	}
	if len(m.FileKeys) > 0 {
		for iNdEx := len(m.FileKeys) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.FileKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintChanges(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.Content) > 0 {
		for iNdEx := len(m.Content) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Content[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintChanges(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *StoreChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ChangeSet) > 0 {
		for iNdEx := len(m.ChangeSet) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ChangeSet[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintChanges(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *StoreChangeContentChangeOfDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Delete != nil {
		{
			size, err := m.Delete.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintChanges(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *DocumentCreate) 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 *DocumentCreate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DocumentCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintChanges(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.DocumentId) > 0 {
		i -= len(m.DocumentId)
		copy(dAtA[i:], m.DocumentId)
		i = encodeVarintChanges(dAtA, i, uint64(len(m.DocumentId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Collection) > 0 {
		i -= len(m.Collection)
		copy(dAtA[i:], m.Collection)
		i = encodeVarintChanges(dAtA, i, uint64(len(m.Collection)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *DocumentModify) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Keys) > 0 {
		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Keys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintChanges(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.DocumentId) > 0 {
		i -= len(m.DocumentId)
		copy(dAtA[i:], m.DocumentId)
		i = encodeVarintChanges(dAtA, i, uint64(len(m.DocumentId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Collection) > 0 {
		i -= len(m.Collection)
		copy(dAtA[i:], m.Collection)
		i = encodeVarintChanges(dAtA, i, uint64(len(m.Collection)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *KeyModify) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ModifyValue) > 0 {
		i -= len(m.ModifyValue)
		copy(dAtA[i:], m.ModifyValue)
		i = encodeVarintChanges(dAtA, i, uint64(len(m.ModifyValue)))
		i--
		dAtA[i] = 0x22
	}
	if m.ModifyOp != 0 {
		i = encodeVarintChanges(dAtA, i, uint64(m.ModifyOp))
		i--
		dAtA[i] = 0x18
	}
	if len(m.KeyPath) > 0 {
		for iNdEx := len(m.KeyPath) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.KeyPath[iNdEx])
			copy(dAtA[i:], m.KeyPath[iNdEx])
			i = encodeVarintChanges(dAtA, i, uint64(len(m.KeyPath[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func encodeVarintChanges(dAtA []byte, offset int, v uint64) int {
	offset -= sovChanges(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Change) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Content) > 0 {
		for _, e := range m.Content {
			l = e.Size()
			n += 1 + l + sovChanges(uint64(l))
		}
	}
	if m.Snapshot != nil {
		l = m.Snapshot.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	if len(m.FileKeys) > 0 {
		for _, e := range m.FileKeys {
			l = e.Size()
			n += 1 + l + sovChanges(uint64(l))
		}
	}
	if m.Timestamp != 0 {
		n += 1 + sovChanges(uint64(m.Timestamp))
	}
	if m.Version != 0 {
		n += 1 + sovChanges(uint64(m.Version))
	}
	return n
}

func (m *ChangeSnapshot) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.LogHeads) > 0 {
		for k, v := range m.LogHeads {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovChanges(uint64(len(k))) + 1 + len(v) + sovChanges(uint64(len(v)))
			n += mapEntrySize + 1 + sovChanges(uint64(mapEntrySize))
		}
	}
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	if len(m.FileKeys) > 0 {
		for _, e := range m.FileKeys {
			l = e.Size()
			n += 1 + l + sovChanges(uint64(l))
		}
	}
	return n
}

func (m *ChangeFileKeys) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	if len(m.Keys) > 0 {
		for k, v := range m.Keys {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovChanges(uint64(len(k))) + 1 + len(v) + sovChanges(uint64(len(v)))
			n += mapEntrySize + 1 + sovChanges(uint64(mapEntrySize))
		}
	}
	return n
}

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

func (m *ChangeContentValueOfBlockCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockCreate != nil {
		l = m.BlockCreate.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfBlockUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockUpdate != nil {
		l = m.BlockUpdate.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfBlockRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockRemove != nil {
		l = m.BlockRemove.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfBlockMove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockMove != nil {
		l = m.BlockMove.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfBlockDuplicate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockDuplicate != nil {
		l = m.BlockDuplicate.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfRelationAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RelationAdd != nil {
		l = m.RelationAdd.Size()
		n += 2 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfRelationRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RelationRemove != nil {
		l = m.RelationRemove.Size()
		n += 2 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfDetailsSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DetailsSet != nil {
		l = m.DetailsSet.Size()
		n += 2 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfDetailsUnset) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DetailsUnset != nil {
		l = m.DetailsUnset.Size()
		n += 2 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfObjectTypeAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectTypeAdd != nil {
		l = m.ObjectTypeAdd.Size()
		n += 2 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfObjectTypeRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectTypeRemove != nil {
		l = m.ObjectTypeRemove.Size()
		n += 2 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfStoreKeySet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StoreKeySet != nil {
		l = m.StoreKeySet.Size()
		n += 2 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfStoreKeyUnset) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StoreKeyUnset != nil {
		l = m.StoreKeyUnset.Size()
		n += 2 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfStoreSliceUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StoreSliceUpdate != nil {
		l = m.StoreSliceUpdate.Size()
		n += 2 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfOriginalCreatedTimestampSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OriginalCreatedTimestampSet != nil {
		l = m.OriginalCreatedTimestampSet.Size()
		n += 2 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfSetFileInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SetFileInfo != nil {
		l = m.SetFileInfo.Size()
		n += 2 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfNotificationCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NotificationCreate != nil {
		l = m.NotificationCreate.Size()
		n += 2 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfNotificationUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NotificationUpdate != nil {
		l = m.NotificationUpdate.Size()
		n += 2 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfDeviceAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DeviceAdd != nil {
		l = m.DeviceAdd.Size()
		n += 2 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeContentValueOfDeviceUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DeviceUpdate != nil {
		l = m.DeviceUpdate.Size()
		n += 2 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeBlockCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TargetId)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	if m.Position != 0 {
		n += 1 + sovChanges(uint64(m.Position))
	}
	if len(m.Blocks) > 0 {
		for _, e := range m.Blocks {
			l = e.Size()
			n += 1 + l + sovChanges(uint64(l))
		}
	}
	return n
}

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

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

func (m *ChangeBlockMove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TargetId)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	if m.Position != 0 {
		n += 1 + sovChanges(uint64(m.Position))
	}
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovChanges(uint64(l))
		}
	}
	return n
}

func (m *ChangeBlockDuplicate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TargetId)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	if m.Position != 0 {
		n += 1 + sovChanges(uint64(m.Position))
	}
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovChanges(uint64(l))
		}
	}
	return n
}

func (m *ChangeDetailsSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	if m.Value != nil {
		l = m.Value.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}

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

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

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

func (m *ChangeObjectTypeAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}

func (m *ChangeObjectTypeRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}

func (m *ChangeStoreKeySet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Path) > 0 {
		for _, s := range m.Path {
			l = len(s)
			n += 1 + l + sovChanges(uint64(l))
		}
	}
	if m.Value != nil {
		l = m.Value.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}

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

func (m *ChangeStoreSliceUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	if m.Operation != nil {
		n += m.Operation.Size()
	}
	return n
}

func (m *ChangeStoreSliceUpdateOperationOfAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Add != nil {
		l = m.Add.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeStoreSliceUpdateOperationOfRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Remove != nil {
		l = m.Remove.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeStoreSliceUpdateOperationOfMove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Move != nil {
		l = m.Move.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *ChangeStoreSliceUpdateAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AfterId)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovChanges(uint64(l))
		}
	}
	return n
}

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

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

func (m *ChangeOriginalCreatedTimestampSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ts != 0 {
		n += 1 + sovChanges(uint64(m.Ts))
	}
	return n
}

func (m *ChangeSetFileInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FileInfo != nil {
		l = m.FileInfo.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}

func (m *ChangeNotificationCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Notification != nil {
		l = m.Notification.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}

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

func (m *ChangeDeviceAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Device != nil {
		l = m.Device.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}

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

func (m *ChangeNoSnapshot) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Content) > 0 {
		for _, e := range m.Content {
			l = e.Size()
			n += 1 + l + sovChanges(uint64(l))
		}
	}
	if len(m.FileKeys) > 0 {
		for _, e := range m.FileKeys {
			l = e.Size()
			n += 1 + l + sovChanges(uint64(l))
		}
	}
	if m.Timestamp != 0 {
		n += 1 + sovChanges(uint64(m.Timestamp))
	}
	if m.Version != 0 {
		n += 1 + sovChanges(uint64(m.Version))
	}
	return n
}

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

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

func (m *StoreChangeContentChangeOfCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Create != nil {
		l = m.Create.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *StoreChangeContentChangeOfModify) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Modify != nil {
		l = m.Modify.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *StoreChangeContentChangeOfDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Delete != nil {
		l = m.Delete.Size()
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}
func (m *DocumentCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Collection)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	l = len(m.DocumentId)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}

func (m *DocumentModify) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Collection)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	l = len(m.DocumentId)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	if len(m.Keys) > 0 {
		for _, e := range m.Keys {
			l = e.Size()
			n += 1 + l + sovChanges(uint64(l))
		}
	}
	return n
}

func (m *KeyModify) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.KeyPath) > 0 {
		for _, s := range m.KeyPath {
			l = len(s)
			n += 1 + l + sovChanges(uint64(l))
		}
	}
	if m.ModifyOp != 0 {
		n += 1 + sovChanges(uint64(m.ModifyOp))
	}
	l = len(m.ModifyValue)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}

func (m *DocumentDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Collection)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	l = len(m.DocumentId)
	if l > 0 {
		n += 1 + l + sovChanges(uint64(l))
	}
	return n
}

func sovChanges(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozChanges(x uint64) (n int) {
	return sovChanges(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Change) 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 ErrIntOverflowChanges
			}
			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: Change: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Change: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 3:
			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 ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Content = append(m.Content, &ChangeContent{})
			if err := m.Content[len(m.Content)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Snapshot == nil {
				m.Snapshot = &ChangeSnapshot{}
			}
			if err := m.Snapshot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileKeys", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FileKeys = append(m.FileKeys, &ChangeFileKeys{})
			if err := m.FileKeys[len(m.FileKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			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 ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeSnapshot) 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 ErrIntOverflowChanges
			}
			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: Snapshot: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Snapshot: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogHeads", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LogHeads == nil {
				m.LogHeads = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowChanges
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowChanges
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthChanges
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthChanges
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowChanges
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthChanges
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthChanges
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipChanges(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthChanges
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.LogHeads[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &model.SmartBlockSnapshotBase{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileKeys", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FileKeys = append(m.FileKeys, &ChangeFileKeys{})
			if err := m.FileKeys[len(m.FileKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeFileKeys) 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 ErrIntOverflowChanges
			}
			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: FileKeys: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FileKeys: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Keys == nil {
				m.Keys = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowChanges
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowChanges
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthChanges
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthChanges
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowChanges
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthChanges
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthChanges
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipChanges(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthChanges
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Keys[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeContent) 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 ErrIntOverflowChanges
			}
			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: Content: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Content: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockCreate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeBlockCreate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfBlockCreate{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeBlockUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfBlockUpdate{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeBlockRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfBlockRemove{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockMove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeBlockMove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfBlockMove{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockDuplicate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeBlockDuplicate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfBlockDuplicate{v}
			iNdEx = postIndex
		case 50:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationAdd", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeRelationAdd{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfRelationAdd{v}
			iNdEx = postIndex
		case 51:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeRelationRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfRelationRemove{v}
			iNdEx = postIndex
		case 100:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DetailsSet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeDetailsSet{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfDetailsSet{v}
			iNdEx = postIndex
		case 101:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DetailsUnset", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeDetailsUnset{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfDetailsUnset{v}
			iNdEx = postIndex
		case 105:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectTypeAdd", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeObjectTypeAdd{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfObjectTypeAdd{v}
			iNdEx = postIndex
		case 106:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectTypeRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeObjectTypeRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfObjectTypeRemove{v}
			iNdEx = postIndex
		case 107:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoreKeySet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeStoreKeySet{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfStoreKeySet{v}
			iNdEx = postIndex
		case 108:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoreKeyUnset", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeStoreKeyUnset{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfStoreKeyUnset{v}
			iNdEx = postIndex
		case 109:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoreSliceUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeStoreSliceUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfStoreSliceUpdate{v}
			iNdEx = postIndex
		case 110:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginalCreatedTimestampSet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeOriginalCreatedTimestampSet{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfOriginalCreatedTimestampSet{v}
			iNdEx = postIndex
		case 111:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SetFileInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeSetFileInfo{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfSetFileInfo{v}
			iNdEx = postIndex
		case 112:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotificationCreate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeNotificationCreate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfNotificationCreate{v}
			iNdEx = postIndex
		case 113:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotificationUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeNotificationUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfNotificationUpdate{v}
			iNdEx = postIndex
		case 114:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceAdd", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeDeviceAdd{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfDeviceAdd{v}
			iNdEx = postIndex
		case 115:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeDeviceUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ChangeContentValueOfDeviceUpdate{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeBlockCreate) 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 ErrIntOverflowChanges
			}
			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: BlockCreate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockCreate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
			}
			m.Position = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Position |= model.BlockPosition(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Blocks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Blocks = append(m.Blocks, &model.Block{})
			if err := m.Blocks[len(m.Blocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeBlockRemove) 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 ErrIntOverflowChanges
			}
			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: BlockRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ids = append(m.Ids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeBlockMove) 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 ErrIntOverflowChanges
			}
			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: BlockMove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockMove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
			}
			m.Position = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Position |= model.BlockPosition(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ids = append(m.Ids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeBlockDuplicate) 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 ErrIntOverflowChanges
			}
			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: BlockDuplicate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockDuplicate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
			}
			m.Position = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Position |= model.BlockPosition(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ids = append(m.Ids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeDetailsSet) 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 ErrIntOverflowChanges
			}
			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: DetailsSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DetailsSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Value == nil {
				m.Value = &types.Value{}
			}
			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeDetailsUnset) 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 ErrIntOverflowChanges
			}
			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: DetailsUnset: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DetailsUnset: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeRelationRemove) 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 ErrIntOverflowChanges
			}
			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: RelationRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelationRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = append(m.RelationKey, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeObjectTypeAdd) 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 ErrIntOverflowChanges
			}
			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: ObjectTypeAdd: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ObjectTypeAdd: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeObjectTypeRemove) 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 ErrIntOverflowChanges
			}
			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: ObjectTypeRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ObjectTypeRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeStoreKeySet) 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 ErrIntOverflowChanges
			}
			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: StoreKeySet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StoreKeySet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = append(m.Path, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Value == nil {
				m.Value = &types.Value{}
			}
			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeStoreKeyUnset) 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 ErrIntOverflowChanges
			}
			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: StoreKeyUnset: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StoreKeyUnset: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = append(m.Path, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeStoreSliceUpdate) 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 ErrIntOverflowChanges
			}
			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: StoreSliceUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StoreSliceUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Add", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeStoreSliceUpdateAdd{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Operation = &ChangeStoreSliceUpdateOperationOfAdd{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Remove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeStoreSliceUpdateRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Operation = &ChangeStoreSliceUpdateOperationOfRemove{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Move", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeStoreSliceUpdateMove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Operation = &ChangeStoreSliceUpdateOperationOfMove{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeStoreSliceUpdateAdd) 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 ErrIntOverflowChanges
			}
			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: Add: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Add: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AfterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AfterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ids = append(m.Ids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeStoreSliceUpdateRemove) 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 ErrIntOverflowChanges
			}
			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: Remove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Remove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ids = append(m.Ids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeStoreSliceUpdateMove) 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 ErrIntOverflowChanges
			}
			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: Move: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Move: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AfterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AfterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ids = append(m.Ids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeOriginalCreatedTimestampSet) 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 ErrIntOverflowChanges
			}
			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: OriginalCreatedTimestampSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OriginalCreatedTimestampSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ts", wireType)
			}
			m.Ts = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ts |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeNotificationUpdate) 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 ErrIntOverflowChanges
			}
			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: NotificationUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NotificationUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= model.NotificationStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeDeviceUpdate) 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 ErrIntOverflowChanges
			}
			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: DeviceUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeviceUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChangeNoSnapshot) 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 ErrIntOverflowChanges
			}
			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: ChangeNoSnapshot: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChangeNoSnapshot: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 3:
			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 ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Content = append(m.Content, &ChangeContent{})
			if err := m.Content[len(m.Content)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileKeys", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FileKeys = append(m.FileKeys, &ChangeFileKeys{})
			if err := m.FileKeys[len(m.FileKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			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 ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StoreChangeContent) 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 ErrIntOverflowChanges
			}
			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: StoreChangeContent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StoreChangeContent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Create", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DocumentCreate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Change = &StoreChangeContentChangeOfCreate{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Modify", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DocumentModify{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Change = &StoreChangeContentChangeOfModify{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delete", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DocumentDelete{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Change = &StoreChangeContentChangeOfDelete{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DocumentCreate) 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 ErrIntOverflowChanges
			}
			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: DocumentCreate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DocumentCreate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Collection", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Collection = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DocumentId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DocumentId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DocumentModify) 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 ErrIntOverflowChanges
			}
			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: DocumentModify: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DocumentModify: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Collection", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Collection = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DocumentId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DocumentId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthChanges
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Keys = append(m.Keys, &KeyModify{})
			if err := m.Keys[len(m.Keys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KeyModify) 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 ErrIntOverflowChanges
			}
			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: KeyModify: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KeyModify: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.KeyPath = append(m.KeyPath, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ModifyOp", wireType)
			}
			m.ModifyOp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ModifyOp |= ModifyOp(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ModifyValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ModifyValue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DocumentDelete) 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 ErrIntOverflowChanges
			}
			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: DocumentDelete: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DocumentDelete: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Collection", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Collection = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DocumentId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowChanges
				}
				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 ErrInvalidLengthChanges
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthChanges
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DocumentId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipChanges(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthChanges
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipChanges(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, ErrIntOverflowChanges
			}
			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, ErrIntOverflowChanges
				}
				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, ErrIntOverflowChanges
				}
				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, ErrInvalidLengthChanges
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupChanges
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthChanges
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthChanges        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowChanges          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupChanges = fmt.Errorf("proto: unexpected end of group")
)
