diff --git a/core/block/editor/smartblock/smartblock.go b/core/block/editor/smartblock/smartblock.go
index 3dcadb3c9..315e27423 100644
--- a/core/block/editor/smartblock/smartblock.go
+++ b/core/block/editor/smartblock/smartblock.go
@@ -638,7 +638,7 @@ func (sb *smartBlock) Apply(s *state.State, flags ...ApplyFlag) (err error) {
 			act.Group = s.GroupId()
 			sb.undo.Add(act)
 		}
-	} else if hasCollectionChanges(changes) { // TODO: change to len(changes) > 0
+	} else if hasStoreChanges(changes) { // TODO: change to len(changes) > 0
 		pushChange()
 	}
 	if sendEvent {
@@ -1598,9 +1598,9 @@ func ApplyTemplate(sb SmartBlock, s *state.State, templates ...template.StateTra
 	return sb.Apply(s, NoHistory, NoEvent, NoRestrictions, SkipIfNoChanges)
 }
 
-func hasCollectionChanges(changes []*pb.ChangeContent) bool {
+func hasStoreChanges(changes []*pb.ChangeContent) bool {
 	for _, ch := range changes {
-		if ch.GetCollectionKeySet() != nil || ch.GetCollectionKeyUnset() != nil {
+		if ch.GetStoreKeySet() != nil || ch.GetStoreKeyUnset() != nil {
 			return true
 		}
 	}
diff --git a/core/block/editor/state/change.go b/core/block/editor/state/change.go
index 3a352e585..20e3b49c6 100644
--- a/core/block/editor/state/change.go
+++ b/core/block/editor/state/change.go
@@ -38,7 +38,7 @@ func NewDocFromSnapshot(rootId string, snapshot *pb.ChangeSnapshot) Doc {
 		extraRelations: snapshot.Data.ExtraRelations,
 		objectTypes:    snapshot.Data.ObjectTypes,
 		fileKeys:       fileKeys,
-		collections:    snapshot.Data.Collections,
+		store:          snapshot.Data.Collections,
 	}
 	s.InjectDerivedDetails()
 
@@ -150,12 +150,12 @@ func (s *State) applyChange(ch *pb.ChangeContent) (err error) {
 		if err = s.changeObjectTypeRemove(ch.GetObjectTypeRemove()); err != nil {
 			return
 		}
-	case ch.GetCollectionKeySet() != nil:
-		if err = s.changeCollectionKeySet(ch.GetCollectionKeySet()); err != nil {
+	case ch.GetStoreKeySet() != nil:
+		if err = s.changeStoreKeySet(ch.GetStoreKeySet()); err != nil {
 			return
 		}
-	case ch.GetCollectionKeyUnset() != nil:
-		if err = s.changeCollectionKeyUnset(ch.GetCollectionKeyUnset()); err != nil {
+	case ch.GetStoreKeyUnset() != nil:
+		if err = s.changeStoreKeyUnset(ch.GetStoreKeyUnset()); err != nil {
 			return
 		}
 	default:
@@ -319,13 +319,13 @@ func (s *State) changeBlockMove(move *pb.ChangeBlockMove) error {
 	return err
 }
 
-func (s *State) changeCollectionKeySet(set *pb.ChangeCollectionKeySet) error {
-	s.setInCollection(set.Key, set.Value)
+func (s *State) changeStoreKeySet(set *pb.ChangeStoreKeySet) error {
+	s.setInStore(set.Path, set.Value)
 	return nil
 }
 
-func (s *State) changeCollectionKeyUnset(unset *pb.ChangeCollectionKeyUnset) error {
-	s.removeFromCollection(unset.Key)
+func (s *State) changeStoreKeyUnset(unset *pb.ChangeStoreKeyUnset) error {
+	s.removeFromStore(unset.Path)
 	return nil
 }
 
@@ -425,7 +425,7 @@ func (s *State) fillChanges(msgs []simple.EventMessage) {
 			},
 		})
 	}
-	s.collapseSameKeyCollectionChanges()
+	s.collapseSameKeyStoreChanges()
 	s.changes = cb.Build()
 	s.changes = append(s.changes, s.makeDetailsChanges()...)
 	s.changes = append(s.changes, s.makeRelationsChanges()...)
@@ -528,16 +528,16 @@ func (s *State) makeDetailsChanges() (ch []*pb.ChangeContent) {
 	return
 }
 
-func (s *State) collapseSameKeyCollectionChanges() {
+func (s *State) collapseSameKeyStoreChanges() {
 	seen := make(map[string]struct{}, len(s.changes))
 	var filteredChanges []*pb.ChangeContent
 	for i := len(s.changes) - 1; i >= 0; i-- {
 		ch := s.changes[i]
 		var key []string
-		if ch.GetCollectionKeySet() != nil {
-			key = ch.GetCollectionKeySet().Key
-		} else if ch.GetCollectionKeyUnset() != nil {
-			key = ch.GetCollectionKeyUnset().Key
+		if ch.GetStoreKeySet() != nil {
+			key = ch.GetStoreKeySet().Path
+		} else if ch.GetStoreKeyUnset() != nil {
+			key = ch.GetStoreKeyUnset().Path
 		} else {
 			filteredChanges = append(filteredChanges, ch)
 			continue
diff --git a/core/block/editor/state/change_test.go b/core/block/editor/state/change_test.go
index 28721ee1e..910e18488 100644
--- a/core/block/editor/state/change_test.go
+++ b/core/block/editor/state/change_test.go
@@ -14,7 +14,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func makeCollectionWithTwoKeysAndValue(first, second, value string) *types.Struct {
+func makeStoreWithTwoKeysAndValue(first, second, value string) *types.Struct {
 	return &types.Struct{
 		Fields: map[string]*types.Value{
 			first: {Kind: &types.Value_StructValue{
@@ -56,16 +56,16 @@ func TestState_ChangesCreate_MoveAdd(t *testing.T) {
 func TestState_ChangesCreate_Collection_Set(t *testing.T) {
 	d := NewDoc("root", nil)
 	s := d.NewState()
-	s.SetInCollection([]string{"coll1", "key1"}, pbtypes.String("1"))
+	s.SetInStore([]string{"coll1", "key1"}, pbtypes.String("1"))
 	_, _, err := ApplyState(s, true)
 	require.NoError(t, err)
 	changes := d.(*State).GetChanges()
 	require.Len(t, changes, 1)
 	assert.Equal(t, (&pb.ChangeContent{
-		Value: &pb.ChangeContentValueOfCollectionKeySet{
-			CollectionKeySet: &pb.ChangeCollectionKeySet{
-				Key:            []string{"coll1", "key1"},
-				Value:          pbtypes.String("1"),
+		Value: &pb.ChangeContentValueOfStoreKeySet{
+			StoreKeySet: &pb.ChangeStoreKeySet{
+				Path:  []string{"coll1", "key1"},
+				Value: pbtypes.String("1"),
 			},
 		},
 	}).String(), changes[0].String())
@@ -73,17 +73,17 @@ func TestState_ChangesCreate_Collection_Set(t *testing.T) {
 
 func TestState_ChangesCreate_Collection_Unset(t *testing.T) {
 	d := NewDoc("root", nil)
-	d.(*State).collections = makeCollectionWithTwoKeysAndValue("coll1", "key1", "1")
+	d.(*State).store = makeStoreWithTwoKeysAndValue("coll1", "key1", "1")
 	s := d.NewState()
-	s.RemoveFromCollection([]string{"coll1", "key1"})
+	s.RemoveFromStore([]string{"coll1", "key1"})
 	_, _, err := ApplyState(s, true)
 	require.NoError(t, err)
 	changes := d.(*State).GetChanges()
 	require.Len(t, changes, 1)
 	assert.Equal(t, (&pb.ChangeContent{
-		Value: &pb.ChangeContentValueOfCollectionKeyUnset{
-			CollectionKeyUnset: &pb.ChangeCollectionKeyUnset{
-				Key:            []string{"coll1", "key1"},
+		Value: &pb.ChangeContentValueOfStoreKeyUnset{
+			StoreKeyUnset: &pb.ChangeStoreKeyUnset{
+				Path: []string{"coll1", "key1"},
 			},
 		},
 	}).String(), changes[0].String())
@@ -463,30 +463,30 @@ func Test_ApplyChange(t *testing.T) {
 
 		s := root.NewState()
 		require.NoError(t, s.ApplyChange(&pb.ChangeContent{
-			Value: &pb.ChangeContentValueOfCollectionKeySet{
-				CollectionKeySet: &pb.ChangeCollectionKeySet{
-					Key:            []string{"coll1", "key1"},
-					Value:          pbtypes.String("1"),
+			Value: &pb.ChangeContentValueOfStoreKeySet{
+				StoreKeySet: &pb.ChangeStoreKeySet{
+					Path:   []string{"coll1", "key1"},
+					Value: pbtypes.String("1"),
 				},
 			},
 		}))
-		assert.Equal(t, makeCollectionWithTwoKeysAndValue("coll1", "key1", "1"), s.Collections())
+		assert.Equal(t, makeStoreWithTwoKeysAndValue("coll1", "key1", "1"), s.Store())
 
 		require.NoError(t, s.ApplyChange(&pb.ChangeContent{
-			Value: &pb.ChangeContentValueOfCollectionKeyUnset{
-				CollectionKeyUnset: &pb.ChangeCollectionKeyUnset{
-					Key:            []string{"coll1", "key1"},
+			Value: &pb.ChangeContentValueOfStoreKeyUnset{
+				StoreKeyUnset: &pb.ChangeStoreKeyUnset{
+					Path: []string{"coll1", "key1"},
 				},
 			},
 		}))
 		require.NoError(t, s.ApplyChange(&pb.ChangeContent{
-			Value: &pb.ChangeContentValueOfCollectionKeyUnset{
-				CollectionKeyUnset: &pb.ChangeCollectionKeyUnset{
-					Key:            []string{"coll1", "key1"},
+			Value: &pb.ChangeContentValueOfStoreKeyUnset{
+				StoreKeyUnset: &pb.ChangeStoreKeyUnset{
+					Path: []string{"coll1", "key1"},
 				},
 			},
 		}))
-		assert.Equal(t, &types.Struct{Fields: map[string]*types.Value{}}, s.Collections())
+		assert.Equal(t, &types.Struct{Fields: map[string]*types.Value{}}, s.Store())
 	})
 }
 
diff --git a/core/block/editor/state/state.go b/core/block/editor/state/state.go
index 4dfede239..28f36af53 100644
--- a/core/block/editor/state/state.go
+++ b/core/block/editor/state/state.go
@@ -82,7 +82,7 @@ type State struct {
 	extraRelations              []*model.Relation
 	aggregatedOptionsByRelation map[string][]*model.RelationOption
 
-	collections *types.Struct
+	store       *types.Struct
 	objectTypes []string
 
 	changesStructureIgnoreIds []string
@@ -600,8 +600,8 @@ func (s *State) apply(fast, one, withLayouts bool) (msgs []simple.EventMessage,
 		s.parent.aggregatedOptionsByRelation = s.aggregatedOptionsByRelation
 	}
 
-	if s.parent != nil && s.collections != nil {
-		s.parent.collections = s.collections
+	if s.parent != nil && s.store != nil {
+		s.parent.store = s.store
 	}
 
 	log.Infof("middle: state apply: %d affected; %d for remove; %d copied; %d changes; for a %v", len(affectedIds), len(toRemove), len(s.blocks), len(s.changes), time.Since(st))
@@ -630,8 +630,8 @@ func (s *State) intermediateApply() {
 	if s.objectTypes != nil {
 		s.parent.objectTypes = s.objectTypes
 	}
-	if s.collections != nil {
-		s.parent.collections = s.collections
+	if s.store != nil {
+		s.parent.store = s.store
 	}
 	if len(s.fileKeys) > 0 {
 		s.parent.fileKeys = append(s.parent.fileKeys, s.fileKeys...)
@@ -1327,7 +1327,7 @@ func (s *State) Copy() *State {
 		aggregatedOptionsByRelation: agOptsCopy,
 		objectTypes:                 objTypes,
 		noObjectType:                s.noObjectType,
-		collections:                 pbtypes.CopyStruct(s.Collections()),
+		store:                       pbtypes.CopyStruct(s.Store()),
 	}
 	return copy
 }
@@ -1403,53 +1403,53 @@ func (s *State) RemoveLocalDetail(keys ...string) (ok bool) {
 	return
 }
 
-func (s *State) createOrCopyCollectionsFromParent() {
-	// for simplicity each time we are copying collections in their entirety
-	// the benefit of this is that you are sure that you will not have collections on different levels
+func (s *State) createOrCopyStoreFromParent() {
+	// for simplicity each time we are copying store in their entirety
+	// the benefit of this is that you are sure that you will not have store on different levels
 	// this may not be very good performance/memory wise, but it is simple, so it can stay for now
-	if s.collections != nil {
+	if s.store != nil {
 		return
 	}
-	s.collections = pbtypes.CopyStruct(s.Collections())
-	if s.collections == nil {
-		s.collections = &types.Struct{Fields: map[string]*types.Value{}}
+	s.store = pbtypes.CopyStruct(s.Store())
+	if s.store == nil {
+		s.store = &types.Struct{Fields: map[string]*types.Value{}}
 	}
 }
 
-func (s *State) SetInCollection(keys []string, value *types.Value) {
-	s.setInCollection(keys, value)
+func (s *State) SetInStore(path []string, value *types.Value) {
+	s.setInStore(path, value)
 	if value != nil {
 		s.changes = append(s.changes, &pb.ChangeContent{
-			Value: &pb.ChangeContentValueOfCollectionKeySet{
-				CollectionKeySet: &pb.ChangeCollectionKeySet{Key: keys, Value: value},
+			Value: &pb.ChangeContentValueOfStoreKeySet{
+				StoreKeySet: &pb.ChangeStoreKeySet{Path: path, Value: value},
 			},
 		})
 	} else {
 		s.changes = append(s.changes, &pb.ChangeContent{
-			Value: &pb.ChangeContentValueOfCollectionKeyUnset{
-				CollectionKeyUnset: &pb.ChangeCollectionKeyUnset{Key: keys},
+			Value: &pb.ChangeContentValueOfStoreKeyUnset{
+				StoreKeyUnset: &pb.ChangeStoreKeyUnset{Path: path},
 			},
 		})
 	}
 }
 
-func (s *State) setInCollection(keys []string, value *types.Value) {
-	if len(keys) == 0 {
+func (s *State) setInStore(path []string, value *types.Value) {
+	if len(path) == 0 {
 		return
 	}
 	// todo: optimize to not copy all collection values, but only the map reusing existing values pointers
-	s.createOrCopyCollectionsFromParent()
-	coll := s.collections
-	nested := keys[:len(keys)-1]
-	collStack := []*types.Struct{coll}
+	s.createOrCopyStoreFromParent()
+	store := s.store
+	nested := path[:len(path)-1]
+	storeStack := []*types.Struct{store}
 	for _, key := range nested {
-		if coll.Fields == nil {
-			coll.Fields = map[string]*types.Value{}
+		if store.Fields == nil {
+			store.Fields = map[string]*types.Value{}
 		}
-		_, ok := coll.Fields[key]
+		_, ok := store.Fields[key]
 		// TODO: refactor this with pbtypes
 		if !ok {
-			coll.Fields[key] = &types.Value{
+			store.Fields[key] = &types.Value{
 				Kind: &types.Value_StructValue{
 					StructValue: &types.Struct{
 						Fields: map[string]*types.Value{},
@@ -1457,9 +1457,9 @@ func (s *State) setInCollection(keys []string, value *types.Value) {
 				},
 			}
 		}
-		_, ok = coll.Fields[key].Kind.(*types.Value_StructValue)
+		_, ok = store.Fields[key].Kind.(*types.Value_StructValue)
 		if !ok {
-			coll.Fields[key] = &types.Value{
+			store.Fields[key] = &types.Value{
 				Kind: &types.Value_StructValue{
 					StructValue: &types.Struct{
 						Fields: map[string]*types.Value{},
@@ -1467,81 +1467,81 @@ func (s *State) setInCollection(keys []string, value *types.Value) {
 				},
 			}
 		}
-		coll = coll.Fields[key].Kind.(*types.Value_StructValue).StructValue
-		collStack = append(collStack, coll)
+		store = store.Fields[key].Kind.(*types.Value_StructValue).StructValue
+		storeStack = append(storeStack, store)
 	}
-	if coll.Fields == nil {
-		coll.Fields = map[string]*types.Value{}
+	if store.Fields == nil {
+		store.Fields = map[string]*types.Value{}
 	}
 	if value != nil {
-		coll.Fields[keys[len(keys)-1]] = value
+		store.Fields[path[len(path)-1]] = value
 		return
 	}
-	delete(coll.Fields, keys[len(keys)-1])
+	delete(store.Fields, path[len(path)-1])
 	// cleaning empty structs from collection to avoid empty pb values
-	idx := len(keys)-2
-	for len(coll.Fields) == 0 && idx >= 0 {
-		delete(collStack[idx].Fields, keys[idx])
-		coll = collStack[idx]
+	idx := len(path)-2
+	for len(store.Fields) == 0 && idx >= 0 {
+		delete(storeStack[idx].Fields, path[idx])
+		store = storeStack[idx]
 		idx--
 	}
 }
 
-func (s *State) ContainsInCollection(keys []string) bool {
-	if len(keys) == 0 {
+func (s *State) ContainsInStore(path []string) bool {
+	if len(path) == 0 {
 		return false
 	}
-	coll := s.Collections()
-	if coll == nil {
+	store := s.Store()
+	if store == nil {
 		return false
 	}
-	nested := keys[:len(keys)-1]
+	nested := path[:len(path)-1]
 	for _, key := range nested {
-		if coll.Fields == nil {
+		if store.Fields == nil {
 			return false
 		}
 		// TODO: refactor this with pbtypes
-		_, ok := coll.Fields[key]
+		_, ok := store.Fields[key]
 		if !ok {
 			return false
 		}
-		_, ok = coll.Fields[key].Kind.(*types.Value_StructValue)
+		_, ok = store.Fields[key].Kind.(*types.Value_StructValue)
 		if !ok {
 			return false
 		}
-		coll = coll.Fields[key].Kind.(*types.Value_StructValue).StructValue
+		store = store.Fields[key].Kind.(*types.Value_StructValue).StructValue
 	}
-	if coll.Fields == nil {
+	if store.Fields == nil {
 		return false
 	}
-	return coll.Fields[keys[len(keys)-1]] != nil
+	return store.Fields[path[len(path)-1]] != nil
 }
 
-func (s *State) RemoveFromCollection(keys []string) bool {
-	res := s.removeFromCollection(keys)
+func (s *State) RemoveFromStore(path []string) bool {
+	res := s.removeFromStore(path)
 	if res {
 		s.changes = append(s.changes, &pb.ChangeContent{
-			Value: &pb.ChangeContentValueOfCollectionKeyUnset{
-				CollectionKeyUnset: &pb.ChangeCollectionKeyUnset{Key: keys},
+			Value: &pb.ChangeContentValueOfStoreKeyUnset{
+				StoreKeyUnset: &pb.ChangeStoreKeyUnset{Path: path},
 			},
 		})
 	}
 	return res
 }
 
-func (s *State) removeFromCollection(keys []string) bool {
-	if len(keys) == 0 {
+func (s *State) removeFromStore(path []string) bool {
+	if len(path) == 0 {
 		return false
 	}
-	if !s.ContainsInCollection(keys) {
+	if !s.ContainsInStore(path) {
 		return false
 	}
-	s.setInCollection(keys, nil)
+	s.setInStore(path, nil)
 	return true
 }
 
 func (s *State) GetCollection(collectionName string) *types.Struct {
-	coll := s.Collections()
+	coll := s.Store()
 	if coll == nil {
 		return nil
 	}
@@ -1556,15 +1556,15 @@ func (s *State) GetCollection(collectionName string) *types.Struct {
 	return coll.Fields[collectionName].Kind.(*types.Value_StructValue).StructValue
 }
 
-func (s *State) Collections() *types.Struct {
+func (s *State) Store() *types.Struct {
 	iterState := s
-	for iterState != nil && iterState.collections == nil {
+	for iterState != nil && iterState.store == nil {
 		iterState = iterState.parent
 	}
 	if iterState == nil {
 		return nil
 	}
-	return iterState.collections
+	return iterState.store
 }
 
 func (s *State) Layout() (model.ObjectTypeLayout, bool) {
diff --git a/core/block/editor/workspaces.go b/core/block/editor/workspaces.go
index 477fffb13..f9910176d 100644
--- a/core/block/editor/workspaces.go
+++ b/core/block/editor/workspaces.go
@@ -59,7 +59,7 @@ func (p *Workspaces) CreateObject(sbType smartblock2.SmartBlockType) (core.Smart
 	if err != nil {
 		return nil, err
 	}
-	st.SetInCollection([]string{source.WorkspaceCollection, threadInfo.ID.String()}, p.pbThreadInfoValueFromStruct(threadInfo))
+	st.SetInStore([]string{source.WorkspaceCollection, threadInfo.ID.String()}, p.pbThreadInfoValueFromStruct(threadInfo))
 
 	return core.NewSmartBlock(threadInfo, p.Anytype()), p.Apply(st)
 }
@@ -70,7 +70,7 @@ func (p *Workspaces) DeleteObject(objectId string) error {
 	if err != nil {
 		return err
 	}
-	st.RemoveFromCollection([]string{source.WorkspaceCollection, objectId})
+	st.RemoveFromStore([]string{source.WorkspaceCollection, objectId})
 	return p.Apply(st)
 }
 
@@ -101,7 +101,7 @@ func (p *Workspaces) AddCreatorInfoIfNeeded() error {
 	if err != nil {
 		return err
 	}
-	st.SetInCollection([]string{source.CreatorCollection, deviceId}, p.pbCreatorInfoValue(info))
+	st.SetInStore([]string{source.CreatorCollection, deviceId}, p.pbCreatorInfoValue(info))
 
 	return p.Apply(st)
 }
@@ -109,11 +109,11 @@ func (p *Workspaces) AddCreatorInfoIfNeeded() error {
 func (p *Workspaces) MigrateMany(infos []threads.ThreadInfo) error {
 	st := p.NewState()
 	for _, info := range infos {
-		if st.ContainsInCollection([]string{source.AccountMigration, info.ID}) {
+		if st.ContainsInStore([]string{source.AccountMigration, info.ID}) {
 			continue
 		}
-		st.SetInCollection([]string{source.AccountMigration, info.ID}, pbtypes.Bool(true))
-		st.SetInCollection([]string{source.WorkspaceCollection, info.ID},
+		st.SetInStore([]string{source.AccountMigration, info.ID}, pbtypes.Bool(true))
+		st.SetInStore([]string{source.WorkspaceCollection, info.ID},
 			p.pbThreadInfoValue(info.ID, info.Key, info.Addrs),
 		)
 	}
@@ -131,7 +131,7 @@ func (p *Workspaces) AddObject(objectId string, key string, addrs []string) erro
 	if err != nil {
 		return err
 	}
-	st.SetInCollection([]string{source.WorkspaceCollection, objectId}, p.pbThreadInfoValue(objectId, key, addrs))
+	st.SetInStore([]string{source.WorkspaceCollection, objectId}, p.pbThreadInfoValue(objectId, key, addrs))
 
 	return p.Apply(st)
 }
@@ -154,7 +154,7 @@ func (p *Workspaces) GetObjectKeyAddrs(objectId string) (string, []string, error
 func (p *Workspaces) SetIsHighlighted(objectId string, value bool) error {
 	// TODO: this should be removed probably in the future?
 	st := p.NewState()
-	st.SetInCollection([]string{source.HighlightedCollection, objectId}, pbtypes.Bool(value))
+	st.SetInStore([]string{source.HighlightedCollection, objectId}, pbtypes.Bool(value))
 	return p.Apply(st)
 }
 
diff --git a/core/block/source/source.go b/core/block/source/source.go
index 175ff63d1..ea394f183 100644
--- a/core/block/source/source.go
+++ b/core/block/source/source.go
@@ -349,7 +349,7 @@ func (s *source) PushChange(params PushChangeParams) (id string, err error) {
 				Details:        params.State.Details(),
 				ExtraRelations: params.State.ExtraRelations(),
 				ObjectTypes:    params.State.ObjectTypes(),
-				Collections:    params.State.Collections(),
+				Collections:    params.State.Store(),
 			},
 			FileKeys: s.getFileHashesForSnapshot(params.FileChangedHashes),
 		}
diff --git a/core/block/source/threaddb.go b/core/block/source/threaddb.go
index 449436a64..38d87b8d3 100644
--- a/core/block/source/threaddb.go
+++ b/core/block/source/threaddb.go
@@ -204,9 +204,9 @@ func (v *threadDB) processThreadActions(buffer []threadsDb.Action) {
 				if err != nil {
 					return nil, err
 				}
-				s.SetInCollection([]string{WorkspaceCollection, action.ID.String()}, val)
+				s.SetInStore([]string{WorkspaceCollection, action.ID.String()}, val)
 			} else if action.Type == threadsDb.ActionDelete {
-				s.RemoveFromCollection([]string{WorkspaceCollection, action.ID.String()})
+				s.RemoveFromStore([]string{WorkspaceCollection, action.ID.String()})
 			}
 		}
 		return
@@ -262,9 +262,9 @@ func (v *threadDB) processThreadAction(action threadsDb.Action) {
 			if err != nil {
 				return nil, err
 			}
-			s.SetInCollection([]string{WorkspaceCollection, action.ID.String()}, val)
+			s.SetInStore([]string{WorkspaceCollection, action.ID.String()}, val)
 		} else if action.Type == threadsDb.ActionDelete {
-			s.RemoveFromCollection([]string{WorkspaceCollection, action.ID.String()})
+			s.RemoveFromStore([]string{WorkspaceCollection, action.ID.String()})
 		}
 		return
 	})
@@ -300,7 +300,7 @@ func (v *threadDB) createState() (*state.State, error) {
 			continue
 		}
 
-		s.SetInCollection([]string{WorkspaceCollection, objId}, val)
+		s.SetInStore([]string{WorkspaceCollection, objId}, val)
 	}
 
 	s.SetDetails(v.getDetails())
diff --git a/core/converter/pbc/pbc.go b/core/converter/pbc/pbc.go
index 454d439dd..5718c9b2b 100644
--- a/core/converter/pbc/pbc.go
+++ b/core/converter/pbc/pbc.go
@@ -22,7 +22,7 @@ func (p *pbc) Convert() (result []byte) {
 			Details:        p.s.Details(),
 			ExtraRelations: p.s.ExtraRelations(),
 			ObjectTypes:    p.s.ObjectTypes(),
-			Collections:    p.s.Collections(),
+			Collections:    p.s.Store(),
 		},
 	}
 	for _, fk := range p.s.GetFileKeys() {
diff --git a/core/converter/pbjson/pbjson.go b/core/converter/pbjson/pbjson.go
index af4c70d73..9e3173689 100644
--- a/core/converter/pbjson/pbjson.go
+++ b/core/converter/pbjson/pbjson.go
@@ -23,7 +23,7 @@ func (p *pbj) Convert() []byte {
 			Details:        p.s.Details(),
 			ExtraRelations: p.s.ExtraRelations(),
 			ObjectTypes:    p.s.ObjectTypes(),
-			Collections:    p.s.Collections(),
+			Collections:    p.s.Store(),
 		},
 	}
 	for _, fk := range p.s.GetFileKeys() {
diff --git a/docs/proto.md b/docs/proto.md
index bcf6b4629..f07ad84bc 100644
--- a/docs/proto.md
+++ b/docs/proto.md
@@ -13,8 +13,6 @@
     - [Change.BlockMove](#anytype.Change.BlockMove)
     - [Change.BlockRemove](#anytype.Change.BlockRemove)
     - [Change.BlockUpdate](#anytype.Change.BlockUpdate)
-    - [Change.CollectionKeySet](#anytype.Change.CollectionKeySet)
-    - [Change.CollectionKeyUnset](#anytype.Change.CollectionKeyUnset)
     - [Change.Content](#anytype.Change.Content)
     - [Change.DetailsSet](#anytype.Change.DetailsSet)
     - [Change.DetailsUnset](#anytype.Change.DetailsUnset)
@@ -29,6 +27,8 @@
     - [Change.RelationUpdate.ObjectTypes](#anytype.Change.RelationUpdate.ObjectTypes)
     - [Change.Snapshot](#anytype.Change.Snapshot)
     - [Change.Snapshot.LogHeadsEntry](#anytype.Change.Snapshot.LogHeadsEntry)
+    - [Change.StoreKeySet](#anytype.Change.StoreKeySet)
+    - [Change.StoreKeyUnset](#anytype.Change.StoreKeyUnset)
   
 - [pb/protos/commands.proto](#pb/protos/commands.proto)
     - [Empty](#anytype.Empty)
@@ -1292,37 +1292,6 @@ the element of change tree used to store and internal apply smartBlock history
 
 
 
-<a name="anytype.Change.CollectionKeySet"></a>
-
-### Change.CollectionKeySet
-
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| key | [string](#string) | repeated |  |
-| value | [google.protobuf.Value](#google.protobuf.Value) |  |  |
-
-
-
-
-
-
-<a name="anytype.Change.CollectionKeyUnset"></a>
-
-### Change.CollectionKeyUnset
-
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| key | [string](#string) | repeated |  |
-
-
-
-
-
-
 <a name="anytype.Change.Content"></a>
 
 ### Change.Content
@@ -1343,8 +1312,8 @@ the element of change tree used to store and internal apply smartBlock history
 | relationUpdate | [Change.RelationUpdate](#anytype.Change.RelationUpdate) |  |  |
 | objectTypeAdd | [Change.ObjectTypeAdd](#anytype.Change.ObjectTypeAdd) |  |  |
 | objectTypeRemove | [Change.ObjectTypeRemove](#anytype.Change.ObjectTypeRemove) |  |  |
-| collectionKeySet | [Change.CollectionKeySet](#anytype.Change.CollectionKeySet) |  |  |
-| collectionKeyUnset | [Change.CollectionKeyUnset](#anytype.Change.CollectionKeyUnset) |  |  |
+| storeKeySet | [Change.StoreKeySet](#anytype.Change.StoreKeySet) |  |  |
+| storeKeyUnset | [Change.StoreKeyUnset](#anytype.Change.StoreKeyUnset) |  |  |
 
 
 
@@ -1557,6 +1526,37 @@ the element of change tree used to store and internal apply smartBlock history
 
 
 
+
+<a name="anytype.Change.StoreKeySet"></a>
+
+### Change.StoreKeySet
+
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| path | [string](#string) | repeated |  |
+| value | [google.protobuf.Value](#google.protobuf.Value) |  |  |
+
+
+
+
+
+
+<a name="anytype.Change.StoreKeyUnset"></a>
+
+### Change.StoreKeyUnset
+
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| path | [string](#string) | repeated |  |
+
+
+
+
+
  
 
  
@@ -15963,7 +15963,7 @@ RelationFormat describes how the underlying data is stored in the google.protobu
 | AnytypeProfile | 515 |  |
 | Date | 516 |  |
 | WorkspaceOld | 517 | deprecated thread-based workspace |
-| Workspace | 518 |  |
+| Workspace | 279 |  |
 
 
  
diff --git a/pb/changes.pb.go b/pb/changes.pb.go
index 7a43f6420..448586155 100644
--- a/pb/changes.pb.go
+++ b/pb/changes.pb.go
@@ -253,8 +253,8 @@ type ChangeContent struct {
 	//	*ChangeContentValueOfRelationUpdate
 	//	*ChangeContentValueOfObjectTypeAdd
 	//	*ChangeContentValueOfObjectTypeRemove
-	//	*ChangeContentValueOfCollectionKeySet
-	//	*ChangeContentValueOfCollectionKeyUnset
+	//	*ChangeContentValueOfStoreKeySet
+	//	*ChangeContentValueOfStoreKeyUnset
 	Value IsChangeContentValue `protobuf_oneof:"value"`
 }
 
@@ -333,27 +333,27 @@ type ChangeContentValueOfObjectTypeAdd struct {
 type ChangeContentValueOfObjectTypeRemove struct {
 	ObjectTypeRemove *ChangeObjectTypeRemove `protobuf:"bytes,106,opt,name=objectTypeRemove,proto3,oneof" json:"objectTypeRemove,omitempty"`
 }
-type ChangeContentValueOfCollectionKeySet struct {
-	CollectionKeySet *ChangeCollectionKeySet `protobuf:"bytes,107,opt,name=collectionKeySet,proto3,oneof" json:"collectionKeySet,omitempty"`
+type ChangeContentValueOfStoreKeySet struct {
+	StoreKeySet *ChangeStoreKeySet `protobuf:"bytes,107,opt,name=storeKeySet,proto3,oneof" json:"storeKeySet,omitempty"`
 }
-type ChangeContentValueOfCollectionKeyUnset struct {
-	CollectionKeyUnset *ChangeCollectionKeyUnset `protobuf:"bytes,108,opt,name=collectionKeyUnset,proto3,oneof" json:"collectionKeyUnset,omitempty"`
+type ChangeContentValueOfStoreKeyUnset struct {
+	StoreKeyUnset *ChangeStoreKeyUnset `protobuf:"bytes,108,opt,name=storeKeyUnset,proto3,oneof" json:"storeKeyUnset,omitempty"`
 }
 
-func (*ChangeContentValueOfBlockCreate) IsChangeContentValue()        {}
-func (*ChangeContentValueOfBlockUpdate) IsChangeContentValue()        {}
-func (*ChangeContentValueOfBlockRemove) IsChangeContentValue()        {}
-func (*ChangeContentValueOfBlockMove) IsChangeContentValue()          {}
-func (*ChangeContentValueOfBlockDuplicate) IsChangeContentValue()     {}
-func (*ChangeContentValueOfDetailsSet) IsChangeContentValue()         {}
-func (*ChangeContentValueOfDetailsUnset) IsChangeContentValue()       {}
-func (*ChangeContentValueOfRelationAdd) IsChangeContentValue()        {}
-func (*ChangeContentValueOfRelationRemove) IsChangeContentValue()     {}
-func (*ChangeContentValueOfRelationUpdate) IsChangeContentValue()     {}
-func (*ChangeContentValueOfObjectTypeAdd) IsChangeContentValue()      {}
-func (*ChangeContentValueOfObjectTypeRemove) IsChangeContentValue()   {}
-func (*ChangeContentValueOfCollectionKeySet) IsChangeContentValue()   {}
-func (*ChangeContentValueOfCollectionKeyUnset) IsChangeContentValue() {}
+func (*ChangeContentValueOfBlockCreate) IsChangeContentValue()      {}
+func (*ChangeContentValueOfBlockUpdate) IsChangeContentValue()      {}
+func (*ChangeContentValueOfBlockRemove) IsChangeContentValue()      {}
+func (*ChangeContentValueOfBlockMove) IsChangeContentValue()        {}
+func (*ChangeContentValueOfBlockDuplicate) IsChangeContentValue()   {}
+func (*ChangeContentValueOfDetailsSet) IsChangeContentValue()       {}
+func (*ChangeContentValueOfDetailsUnset) IsChangeContentValue()     {}
+func (*ChangeContentValueOfRelationAdd) IsChangeContentValue()      {}
+func (*ChangeContentValueOfRelationRemove) IsChangeContentValue()   {}
+func (*ChangeContentValueOfRelationUpdate) IsChangeContentValue()   {}
+func (*ChangeContentValueOfObjectTypeAdd) IsChangeContentValue()    {}
+func (*ChangeContentValueOfObjectTypeRemove) IsChangeContentValue() {}
+func (*ChangeContentValueOfStoreKeySet) IsChangeContentValue()      {}
+func (*ChangeContentValueOfStoreKeyUnset) IsChangeContentValue()    {}
 
 func (m *ChangeContent) GetValue() IsChangeContentValue {
 	if m != nil {
@@ -446,16 +446,16 @@ func (m *ChangeContent) GetObjectTypeRemove() *ChangeObjectTypeRemove {
 	return nil
 }
 
-func (m *ChangeContent) GetCollectionKeySet() *ChangeCollectionKeySet {
-	if x, ok := m.GetValue().(*ChangeContentValueOfCollectionKeySet); ok {
-		return x.CollectionKeySet
+func (m *ChangeContent) GetStoreKeySet() *ChangeStoreKeySet {
+	if x, ok := m.GetValue().(*ChangeContentValueOfStoreKeySet); ok {
+		return x.StoreKeySet
 	}
 	return nil
 }
 
-func (m *ChangeContent) GetCollectionKeyUnset() *ChangeCollectionKeyUnset {
-	if x, ok := m.GetValue().(*ChangeContentValueOfCollectionKeyUnset); ok {
-		return x.CollectionKeyUnset
+func (m *ChangeContent) GetStoreKeyUnset() *ChangeStoreKeyUnset {
+	if x, ok := m.GetValue().(*ChangeContentValueOfStoreKeyUnset); ok {
+		return x.StoreKeyUnset
 	}
 	return nil
 }
@@ -475,8 +475,8 @@ func (*ChangeContent) XXX_OneofWrappers() []interface{} {
 		(*ChangeContentValueOfRelationUpdate)(nil),
 		(*ChangeContentValueOfObjectTypeAdd)(nil),
 		(*ChangeContentValueOfObjectTypeRemove)(nil),
-		(*ChangeContentValueOfCollectionKeySet)(nil),
-		(*ChangeContentValueOfCollectionKeyUnset)(nil),
+		(*ChangeContentValueOfStoreKeySet)(nil),
+		(*ChangeContentValueOfStoreKeyUnset)(nil),
 	}
 }
 
@@ -1253,23 +1253,23 @@ func (m *ChangeObjectTypeRemove) GetUrl() string {
 	return ""
 }
 
-type ChangeCollectionKeySet struct {
-	Key   []string     `protobuf:"bytes,1,rep,name=key,proto3" json:"key,omitempty"`
+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 *ChangeCollectionKeySet) Reset()         { *m = ChangeCollectionKeySet{} }
-func (m *ChangeCollectionKeySet) String() string { return proto.CompactTextString(m) }
-func (*ChangeCollectionKeySet) ProtoMessage()    {}
-func (*ChangeCollectionKeySet) Descriptor() ([]byte, []int) {
+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, 15}
 }
-func (m *ChangeCollectionKeySet) XXX_Unmarshal(b []byte) error {
+func (m *ChangeStoreKeySet) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *ChangeCollectionKeySet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *ChangeStoreKeySet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_ChangeCollectionKeySet.Marshal(b, m, deterministic)
+		return xxx_messageInfo_ChangeStoreKeySet.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -1279,48 +1279,48 @@ func (m *ChangeCollectionKeySet) XXX_Marshal(b []byte, deterministic bool) ([]by
 		return b[:n], nil
 	}
 }
-func (m *ChangeCollectionKeySet) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ChangeCollectionKeySet.Merge(m, src)
+func (m *ChangeStoreKeySet) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ChangeStoreKeySet.Merge(m, src)
 }
-func (m *ChangeCollectionKeySet) XXX_Size() int {
+func (m *ChangeStoreKeySet) XXX_Size() int {
 	return m.Size()
 }
-func (m *ChangeCollectionKeySet) XXX_DiscardUnknown() {
-	xxx_messageInfo_ChangeCollectionKeySet.DiscardUnknown(m)
+func (m *ChangeStoreKeySet) XXX_DiscardUnknown() {
+	xxx_messageInfo_ChangeStoreKeySet.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_ChangeCollectionKeySet proto.InternalMessageInfo
+var xxx_messageInfo_ChangeStoreKeySet proto.InternalMessageInfo
 
-func (m *ChangeCollectionKeySet) GetKey() []string {
+func (m *ChangeStoreKeySet) GetPath() []string {
 	if m != nil {
-		return m.Key
+		return m.Path
 	}
 	return nil
 }
 
-func (m *ChangeCollectionKeySet) GetValue() *types.Value {
+func (m *ChangeStoreKeySet) GetValue() *types.Value {
 	if m != nil {
 		return m.Value
 	}
 	return nil
 }
 
-type ChangeCollectionKeyUnset struct {
-	Key []string `protobuf:"bytes,1,rep,name=key,proto3" json:"key,omitempty"`
+type ChangeStoreKeyUnset struct {
+	Path []string `protobuf:"bytes,1,rep,name=path,proto3" json:"path,omitempty"`
 }
 
-func (m *ChangeCollectionKeyUnset) Reset()         { *m = ChangeCollectionKeyUnset{} }
-func (m *ChangeCollectionKeyUnset) String() string { return proto.CompactTextString(m) }
-func (*ChangeCollectionKeyUnset) ProtoMessage()    {}
-func (*ChangeCollectionKeyUnset) Descriptor() ([]byte, []int) {
+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, 16}
 }
-func (m *ChangeCollectionKeyUnset) XXX_Unmarshal(b []byte) error {
+func (m *ChangeStoreKeyUnset) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *ChangeCollectionKeyUnset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *ChangeStoreKeyUnset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_ChangeCollectionKeyUnset.Marshal(b, m, deterministic)
+		return xxx_messageInfo_ChangeStoreKeyUnset.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -1330,21 +1330,21 @@ func (m *ChangeCollectionKeyUnset) XXX_Marshal(b []byte, deterministic bool) ([]
 		return b[:n], nil
 	}
 }
-func (m *ChangeCollectionKeyUnset) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ChangeCollectionKeyUnset.Merge(m, src)
+func (m *ChangeStoreKeyUnset) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ChangeStoreKeyUnset.Merge(m, src)
 }
-func (m *ChangeCollectionKeyUnset) XXX_Size() int {
+func (m *ChangeStoreKeyUnset) XXX_Size() int {
 	return m.Size()
 }
-func (m *ChangeCollectionKeyUnset) XXX_DiscardUnknown() {
-	xxx_messageInfo_ChangeCollectionKeyUnset.DiscardUnknown(m)
+func (m *ChangeStoreKeyUnset) XXX_DiscardUnknown() {
+	xxx_messageInfo_ChangeStoreKeyUnset.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_ChangeCollectionKeyUnset proto.InternalMessageInfo
+var xxx_messageInfo_ChangeStoreKeyUnset proto.InternalMessageInfo
 
-func (m *ChangeCollectionKeyUnset) GetKey() []string {
+func (m *ChangeStoreKeyUnset) GetPath() []string {
 	if m != nil {
-		return m.Key
+		return m.Path
 	}
 	return nil
 }
@@ -1370,86 +1370,86 @@ func init() {
 	proto.RegisterType((*ChangeRelationRemove)(nil), "anytype.Change.RelationRemove")
 	proto.RegisterType((*ChangeObjectTypeAdd)(nil), "anytype.Change.ObjectTypeAdd")
 	proto.RegisterType((*ChangeObjectTypeRemove)(nil), "anytype.Change.ObjectTypeRemove")
-	proto.RegisterType((*ChangeCollectionKeySet)(nil), "anytype.Change.CollectionKeySet")
-	proto.RegisterType((*ChangeCollectionKeyUnset)(nil), "anytype.Change.CollectionKeyUnset")
+	proto.RegisterType((*ChangeStoreKeySet)(nil), "anytype.Change.StoreKeySet")
+	proto.RegisterType((*ChangeStoreKeyUnset)(nil), "anytype.Change.StoreKeyUnset")
 }
 
 func init() { proto.RegisterFile("pb/protos/changes.proto", fileDescriptor_2b02bba284ea1e46) }
 
 var fileDescriptor_2b02bba284ea1e46 = []byte{
-	// 1144 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0x4d, 0x6f, 0x1b, 0x45,
-	0x18, 0xde, 0xcd, 0x3a, 0xfe, 0x78, 0x37, 0x09, 0x66, 0x14, 0x25, 0xcb, 0x12, 0x8c, 0x1b, 0x4a,
-	0x65, 0x55, 0xd5, 0x5a, 0xb8, 0x88, 0x92, 0x52, 0x84, 0x70, 0x92, 0xca, 0x51, 0x9b, 0x16, 0x4d,
-	0x5a, 0x0e, 0x5c, 0xa2, 0xb1, 0x77, 0xe2, 0x6c, 0xb3, 0xf6, 0xae, 0x76, 0xc6, 0x91, 0xfc, 0x2b,
-	0x40, 0x1c, 0xf9, 0x45, 0x1c, 0x7b, 0xe0, 0xc0, 0x11, 0x25, 0x77, 0x7e, 0x01, 0x07, 0x34, 0xb3,
-	0xb3, 0x9f, 0xb1, 0xc3, 0x87, 0x04, 0x97, 0xc4, 0xef, 0xcc, 0xf3, 0x3c, 0xf3, 0xbe, 0xef, 0xcc,
-	0x3c, 0xb3, 0xb0, 0x1d, 0x0e, 0xbb, 0x61, 0x14, 0xf0, 0x80, 0x75, 0x47, 0xe7, 0x64, 0x3a, 0xa6,
-	0xcc, 0x91, 0x21, 0xaa, 0x91, 0xe9, 0x9c, 0xcf, 0x43, 0x6a, 0xdf, 0x0d, 0x2f, 0xc6, 0x5d, 0xdf,
-	0x1b, 0x76, 0xc3, 0x61, 0x77, 0x12, 0xb8, 0xd4, 0x4f, 0xf0, 0x32, 0x50, 0x70, 0x7b, 0x2b, 0xd3,
-	0xa1, 0x97, 0x74, 0xca, 0x93, 0xf1, 0x9d, 0x71, 0x10, 0x8c, 0x7d, 0x1a, 0xcf, 0x0d, 0x67, 0x67,
-	0x5d, 0xc6, 0xa3, 0xd9, 0x88, 0xc7, 0xb3, 0xbb, 0x3f, 0x59, 0x50, 0xdd, 0x97, 0xcb, 0xa2, 0x3b,
-	0xb0, 0x16, 0x46, 0xf4, 0xd2, 0x0b, 0x66, 0xec, 0xd4, 0x73, 0x99, 0xa5, 0xb7, 0x8d, 0x4e, 0x03,
-	0x9b, 0xc9, 0xd8, 0x91, 0xcb, 0x50, 0x07, 0x9a, 0x3e, 0x61, 0xfc, 0x94, 0x4d, 0x49, 0xc8, 0xce,
-	0x03, 0x7e, 0xea, 0xb9, 0xd6, 0x4a, 0x5b, 0xef, 0x34, 0xf0, 0x86, 0x18, 0x3f, 0x51, 0xc3, 0x47,
-	0x2e, 0xba, 0x0f, 0xef, 0xa6, 0x62, 0x13, 0xca, 0x89, 0x54, 0x5c, 0x95, 0x8a, 0xef, 0x24, 0x13,
-	0xc7, 0x94, 0x13, 0xa1, 0xfa, 0x09, 0xd4, 0x46, 0xc1, 0x94, 0xd3, 0x29, 0xb7, 0x8c, 0xb6, 0xd1,
-	0x31, 0x7b, 0xdb, 0x8e, 0x2a, 0xdd, 0x89, 0x53, 0x73, 0xf6, 0xe3, 0x69, 0x9c, 0xe0, 0xd0, 0xa7,
-	0x50, 0x4f, 0x72, 0xb0, 0x2a, 0x6d, 0xbd, 0x63, 0xf6, 0xac, 0x32, 0x27, 0x49, 0x06, 0xa7, 0x48,
-	0xc1, 0x3a, 0xf3, 0x7c, 0xfa, 0x8c, 0xce, 0x99, 0x55, 0x95, 0x2b, 0xdd, 0x60, 0x3d, 0x55, 0xf3,
-	0x38, 0x45, 0xa2, 0x1d, 0x68, 0x70, 0x6f, 0x42, 0x19, 0x27, 0x93, 0xd0, 0xaa, 0xb5, 0xf5, 0x8e,
-	0x81, 0xb3, 0x01, 0xfb, 0x0f, 0x1d, 0xea, 0xc9, 0x52, 0xa8, 0x0f, 0x75, 0x3f, 0x18, 0x0f, 0x28,
-	0x51, 0xed, 0x33, 0x7b, 0xf7, 0x96, 0xa5, 0xe5, 0x3c, 0x57, 0xc0, 0xc3, 0x29, 0x8f, 0xe6, 0x38,
-	0xe5, 0xa1, 0x3d, 0xa8, 0xb8, 0x84, 0x13, 0xd9, 0x57, 0xb3, 0xf7, 0x71, 0xca, 0x97, 0x9b, 0xed,
-	0x9c, 0x4c, 0x48, 0xc4, 0xfb, 0x7e, 0x30, 0xba, 0x48, 0x84, 0xfa, 0x84, 0x51, 0x2c, 0x29, 0x85,
-	0xfa, 0x8c, 0xbf, 0x5b, 0x9f, 0xfd, 0x05, 0xac, 0x17, 0x72, 0x41, 0x4d, 0x30, 0x2e, 0xe8, 0xdc,
-	0xd2, 0xe5, 0xc6, 0x8a, 0x9f, 0x68, 0x13, 0x56, 0x2f, 0x89, 0x3f, 0xa3, 0x6a, 0xb3, 0xe3, 0xe0,
-	0xf1, 0xca, 0xe7, 0xba, 0xfd, 0xbd, 0x0e, 0xf5, 0x44, 0x13, 0x21, 0xa8, 0x9c, 0x13, 0x76, 0xae,
-	0x98, 0xf2, 0x37, 0xfa, 0x0c, 0x2a, 0x17, 0x22, 0x9f, 0x15, 0x99, 0xcf, 0xee, 0xb2, 0x7c, 0x1c,
-	0xf1, 0x27, 0x6e, 0x85, 0xc4, 0xdb, 0x8f, 0xa0, 0x91, 0x0e, 0xfd, 0xa3, 0x8c, 0x7e, 0xaf, 0x41,
-	0x4d, 0x9d, 0x17, 0xf4, 0x15, 0x98, 0x43, 0xd1, 0xab, 0xfd, 0x88, 0x12, 0x4e, 0x25, 0xdf, 0xec,
-	0xbd, 0x5f, 0xce, 0xa1, 0x9f, 0x41, 0x06, 0x1a, 0xce, 0x33, 0x52, 0x81, 0xd7, 0xa1, 0x2b, 0x04,
-	0x56, 0x6e, 0x11, 0x88, 0x21, 0xa9, 0x40, 0x1c, 0xa6, 0x02, 0x98, 0x4e, 0x82, 0x4b, 0x6a, 0x19,
-	0xb7, 0x08, 0xc4, 0x90, 0x54, 0x20, 0x0e, 0xd1, 0x1e, 0x34, 0x64, 0x78, 0x2c, 0xe8, 0xf1, 0x51,
-	0x7f, 0x6f, 0x21, 0xfd, 0x38, 0x26, 0x67, 0x68, 0x34, 0x80, 0x0d, 0x19, 0x1c, 0xcc, 0x42, 0xdf,
-	0x1b, 0x89, 0xfc, 0x57, 0x25, 0xbf, 0xb5, 0x90, 0x9f, 0xa2, 0x06, 0x1a, 0x2e, 0xf1, 0xd0, 0x13,
-	0x00, 0x97, 0x72, 0xe2, 0xf9, 0xec, 0x84, 0x72, 0xcb, 0x95, 0x2a, 0x76, 0x59, 0xe5, 0x20, 0x45,
-	0x0c, 0x34, 0x9c, 0xc3, 0xa3, 0x3e, 0xac, 0xa9, 0xe8, 0xf5, 0x94, 0x51, 0x6e, 0x51, 0xc9, 0xdf,
-	0x59, 0xc2, 0x97, 0x98, 0x81, 0x86, 0x0b, 0x1c, 0xd1, 0xc7, 0x88, 0xfa, 0x84, 0x7b, 0xc1, 0xf4,
-	0x6b, 0xd7, 0xb5, 0xce, 0x16, 0xf7, 0x11, 0x67, 0x10, 0xd1, 0xc7, 0x1c, 0x43, 0x34, 0x23, 0x09,
-	0xd5, 0x5e, 0x8c, 0x17, 0x37, 0x03, 0x17, 0x50, 0xa2, 0x19, 0x45, 0x5e, 0x5e, 0x49, 0x1d, 0x8b,
-	0xf3, 0xdb, 0x95, 0xd2, 0x93, 0x51, 0xe2, 0xa1, 0x43, 0x58, 0x0f, 0x86, 0x6f, 0xe8, 0x88, 0xbf,
-	0x9a, 0x87, 0x54, 0x94, 0xe5, 0x49, 0xa1, 0x0f, 0xca, 0x42, 0x2f, 0xf3, 0xa0, 0x81, 0x86, 0x8b,
-	0x2c, 0xf4, 0x02, 0x9a, 0xd9, 0x80, 0x2a, 0xee, 0x8d, 0x54, 0x6a, 0x2f, 0x57, 0x4a, 0xcb, 0xbb,
-	0xc1, 0x15, 0x7a, 0xa3, 0xc0, 0xf7, 0xe9, 0x48, 0xa4, 0xfa, 0x8c, 0xce, 0xc5, 0x9e, 0x5f, 0x2c,
-	0xd6, 0xdb, 0x2f, 0xe1, 0x84, 0x5e, 0x99, 0x8b, 0x5e, 0x01, 0x2a, 0x8c, 0xc5, 0xa7, 0xc0, 0x97,
-	0x8a, 0xbb, 0xb7, 0x2a, 0x26, 0x67, 0x61, 0x01, 0xbf, 0x5f, 0x53, 0x0e, 0x60, 0xff, 0xa8, 0x83,
-	0x99, 0xbb, 0xc2, 0xc8, 0x86, 0x3a, 0x27, 0xd1, 0x98, 0xf2, 0x23, 0x57, 0x39, 0x46, 0x1a, 0xa3,
-	0x3d, 0xa8, 0x87, 0x01, 0xf3, 0x84, 0x90, 0xbc, 0xcc, 0x1b, 0xb9, 0x66, 0xc7, 0x06, 0x2b, 0x95,
-	0x9c, 0x6f, 0x14, 0x08, 0xa7, 0x70, 0xf4, 0x00, 0xaa, 0xf2, 0x56, 0x24, 0xd6, 0xba, 0xb9, 0x88,
-	0x88, 0x15, 0xc6, 0xfe, 0x52, 0xe5, 0xa4, 0x76, 0xda, 0x81, 0x6a, 0xfc, 0x28, 0x2b, 0x1f, 0xdc,
-	0x4a, 0xc9, 0x87, 0x62, 0xd8, 0x39, 0xa6, 0x8c, 0x91, 0x31, 0xc5, 0x0a, 0x65, 0x7f, 0xa8, 0xe8,
-	0x6a, 0x47, 0x9a, 0x60, 0x64, 0x2f, 0xb2, 0xf8, 0x69, 0x73, 0x68, 0xa4, 0xb7, 0xfe, 0xbf, 0xaa,
-	0x58, 0xad, 0x6a, 0x64, 0xab, 0xce, 0x61, 0xa3, 0xe8, 0x15, 0xff, 0xdf, 0xd2, 0xcf, 0x01, 0x32,
-	0x83, 0x59, 0xf0, 0x20, 0x3c, 0xc8, 0x3f, 0x08, 0xa2, 0xc1, 0xf1, 0x67, 0x8f, 0x93, 0x7c, 0xf6,
-	0x38, 0xdf, 0x8a, 0x59, 0xf5, 0x50, 0xd8, 0x6d, 0x58, 0xcb, 0xdb, 0xcd, 0x4d, 0x3d, 0xbb, 0x0f,
-	0x66, 0xce, 0x4d, 0xd0, 0x43, 0xa8, 0x27, 0x97, 0x57, 0xad, 0xb0, 0x5d, 0xaa, 0x25, 0xf5, 0x8d,
-	0x14, 0x68, 0xff, 0x62, 0xc0, 0x46, 0xd1, 0x04, 0x16, 0x24, 0xfe, 0x08, 0xaa, 0x67, 0x41, 0x34,
-	0x21, 0x7c, 0x49, 0x8f, 0x12, 0x81, 0xa7, 0x12, 0x34, 0xd0, 0xb0, 0x82, 0xa3, 0x4d, 0xa8, 0x4c,
-	0xc9, 0x24, 0x7e, 0x53, 0x1a, 0x03, 0x0d, 0xcb, 0x08, 0x3d, 0x11, 0x66, 0x7b, 0x46, 0x66, 0x3e,
-	0x97, 0x05, 0xab, 0x27, 0x63, 0x49, 0x3b, 0x62, 0x9b, 0xcd, 0xd0, 0xe8, 0x05, 0x98, 0x99, 0x1d,
-	0x30, 0xf5, 0x5e, 0xdc, 0xbf, 0xdd, 0xd8, 0x72, 0xa6, 0xc2, 0x84, 0xeb, 0xe6, 0x04, 0xd0, 0x16,
-	0xac, 0x4e, 0x66, 0x3e, 0xf7, 0xac, 0x6a, 0x5b, 0xef, 0xd4, 0x07, 0x1a, 0x8e, 0x43, 0x74, 0x08,
-	0xc0, 0xa8, 0xb8, 0xd1, 0x07, 0xde, 0x88, 0xcb, 0x8f, 0x2a, 0xb3, 0xf7, 0xd1, 0x5f, 0x2c, 0x23,
-	0xa0, 0xe2, 0x65, 0xc9, 0x88, 0xf6, 0x63, 0xa8, 0x88, 0xff, 0xa8, 0x07, 0x15, 0x57, 0x08, 0xc5,
-	0x97, 0xab, 0xb5, 0xa4, 0x83, 0xce, 0xcb, 0x50, 0x6e, 0x90, 0xc4, 0xda, 0x5d, 0x30, 0x73, 0x89,
-	0xa3, 0x76, 0xb1, 0x72, 0xf5, 0xf1, 0x9b, 0x1b, 0xca, 0x0c, 0x67, 0x37, 0xdb, 0xd5, 0xec, 0x7e,
-	0x96, 0x8e, 0xcf, 0x1d, 0x58, 0x2f, 0xb8, 0xb6, 0x80, 0xcc, 0x22, 0x3f, 0x81, 0xcc, 0x22, 0xdf,
-	0xbe, 0x0b, 0xcd, 0xb2, 0x1d, 0x2f, 0x40, 0x61, 0x68, 0x96, 0x4d, 0x36, 0x5b, 0xce, 0xf8, 0x77,
-	0xa7, 0xff, 0x1e, 0xa0, 0x9b, 0x36, 0x7b, 0x53, 0xb5, 0xbf, 0xf3, 0xf3, 0x55, 0x4b, 0x7f, 0x7b,
-	0xd5, 0xd2, 0x7f, 0xbb, 0x6a, 0xe9, 0x3f, 0x5c, 0xb7, 0xb4, 0xb7, 0xd7, 0x2d, 0xed, 0xd7, 0xeb,
-	0x96, 0xf6, 0xdd, 0x4a, 0x38, 0x1c, 0x56, 0xa5, 0xf8, 0xc3, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff,
-	0x38, 0x3e, 0xbb, 0xca, 0xc1, 0x0c, 0x00, 0x00,
+	// 1146 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xcf, 0x6f, 0xe3, 0xc4,
+	0x17, 0xb7, 0x9b, 0x34, 0x3f, 0x9e, 0xdb, 0x7e, 0xfb, 0x1d, 0x55, 0xad, 0x31, 0x25, 0x64, 0xbb,
+	0x0b, 0x8a, 0x56, 0x2b, 0x47, 0x64, 0x11, 0x4b, 0x97, 0x45, 0x88, 0xb4, 0x5d, 0xa5, 0x62, 0xbb,
+	0x45, 0x53, 0x96, 0x03, 0x97, 0x6a, 0x12, 0x4f, 0x13, 0x6f, 0x1d, 0xdb, 0xf2, 0x4c, 0x2a, 0xe5,
+	0xaf, 0x00, 0xf1, 0x57, 0x71, 0xec, 0x81, 0x03, 0x47, 0xd4, 0xfe, 0x0f, 0x9c, 0x38, 0xa0, 0x19,
+	0x8f, 0x7f, 0xa5, 0x4e, 0x61, 0x0f, 0x70, 0x49, 0xfc, 0x66, 0x3e, 0x9f, 0xcf, 0xbc, 0xf7, 0x66,
+	0xde, 0x9b, 0x81, 0x9d, 0x70, 0xd8, 0x0d, 0xa3, 0x80, 0x07, 0xac, 0x3b, 0x9a, 0x10, 0x7f, 0x4c,
+	0x99, 0x2d, 0x4d, 0x54, 0x27, 0xfe, 0x9c, 0xcf, 0x43, 0x6a, 0x3d, 0x0a, 0x2f, 0xc7, 0x5d, 0xcf,
+	0x1d, 0x76, 0xc3, 0x61, 0x77, 0x1a, 0x38, 0xd4, 0x4b, 0xf0, 0xd2, 0x50, 0x70, 0x6b, 0x3b, 0xd3,
+	0xa1, 0x57, 0xd4, 0xe7, 0xc9, 0xf8, 0xee, 0x38, 0x08, 0xc6, 0x1e, 0x8d, 0xe7, 0x86, 0xb3, 0x8b,
+	0x2e, 0xe3, 0xd1, 0x6c, 0xc4, 0xe3, 0xd9, 0xbd, 0x3f, 0x76, 0xa0, 0x76, 0x20, 0x97, 0x45, 0x0f,
+	0x60, 0x2d, 0x8c, 0xe8, 0x95, 0x1b, 0xcc, 0xd8, 0xb9, 0xeb, 0x30, 0x53, 0x6f, 0x57, 0x3a, 0x4d,
+	0x6c, 0x24, 0x63, 0xc7, 0x0e, 0x43, 0x1d, 0xd8, 0xf4, 0x08, 0xe3, 0xe7, 0xcc, 0x27, 0x21, 0x9b,
+	0x04, 0xfc, 0xdc, 0x75, 0xcc, 0x95, 0xb6, 0xde, 0x69, 0xe2, 0x0d, 0x31, 0x7e, 0xa6, 0x86, 0x8f,
+	0x1d, 0xf4, 0x18, 0xfe, 0x9f, 0x8a, 0x4d, 0x29, 0x27, 0x52, 0x71, 0x55, 0x2a, 0xfe, 0x2f, 0x99,
+	0x38, 0xa1, 0x9c, 0x08, 0xd5, 0x4f, 0xa0, 0x3e, 0x0a, 0x7c, 0x4e, 0x7d, 0x6e, 0x56, 0xda, 0x95,
+	0x8e, 0xd1, 0xdb, 0xb1, 0x55, 0xe8, 0x76, 0xec, 0x9a, 0x7d, 0x10, 0x4f, 0xe3, 0x04, 0x87, 0x3e,
+	0x85, 0x46, 0xe2, 0x83, 0x59, 0x6d, 0xeb, 0x1d, 0xa3, 0x67, 0x2e, 0x72, 0x12, 0x67, 0x70, 0x8a,
+	0x14, 0xac, 0x0b, 0xd7, 0xa3, 0xdf, 0xd0, 0x39, 0x33, 0x6b, 0x72, 0xa5, 0x3b, 0xac, 0x97, 0x6a,
+	0x1e, 0xa7, 0x48, 0xb4, 0x0b, 0x4d, 0xee, 0x4e, 0x29, 0xe3, 0x64, 0x1a, 0x9a, 0xf5, 0xb6, 0xde,
+	0xa9, 0xe0, 0x6c, 0xc0, 0xfa, 0x53, 0x87, 0x46, 0xb2, 0x14, 0xea, 0x43, 0xc3, 0x0b, 0xc6, 0x03,
+	0x4a, 0x54, 0xfa, 0x8c, 0xde, 0xc7, 0xcb, 0xdc, 0xb2, 0x5f, 0x29, 0xe0, 0x91, 0xcf, 0xa3, 0x39,
+	0x4e, 0x79, 0x68, 0x1f, 0xaa, 0x0e, 0xe1, 0x44, 0xe6, 0xd5, 0xe8, 0x7d, 0x94, 0xf2, 0xe5, 0x66,
+	0xdb, 0x67, 0x53, 0x12, 0xf1, 0xbe, 0x17, 0x8c, 0x2e, 0x13, 0xa1, 0x3e, 0x61, 0x14, 0x4b, 0x4a,
+	0x21, 0xbe, 0xca, 0x3f, 0x8d, 0xcf, 0xfa, 0x02, 0xd6, 0x0b, 0xbe, 0xa0, 0x4d, 0xa8, 0x5c, 0xd2,
+	0xb9, 0xa9, 0xcb, 0x8d, 0x15, 0x9f, 0x68, 0x0b, 0x56, 0xaf, 0x88, 0x37, 0xa3, 0x6a, 0xb3, 0x63,
+	0xe3, 0xf9, 0xca, 0xe7, 0xba, 0xf5, 0xa3, 0x0e, 0x8d, 0x44, 0x13, 0x21, 0xa8, 0x4e, 0x08, 0x9b,
+	0x28, 0xa6, 0xfc, 0x46, 0x9f, 0x41, 0xf5, 0x52, 0xf8, 0xb3, 0x22, 0xfd, 0xd9, 0x5b, 0xe6, 0x8f,
+	0x2d, 0x7e, 0xe2, 0x54, 0x48, 0xbc, 0xf5, 0x0c, 0x9a, 0xe9, 0xd0, 0x3b, 0x79, 0x74, 0x5d, 0x87,
+	0xba, 0x3a, 0x2f, 0xe8, 0x2b, 0x30, 0x86, 0x22, 0x57, 0x07, 0x11, 0x25, 0x9c, 0x4a, 0xbe, 0xd1,
+	0x7b, 0x7f, 0xd1, 0x87, 0x7e, 0x06, 0x19, 0x68, 0x38, 0xcf, 0x48, 0x05, 0xde, 0x84, 0x8e, 0x10,
+	0x58, 0xb9, 0x47, 0x20, 0x86, 0xa4, 0x02, 0xb1, 0x99, 0x0a, 0x60, 0x3a, 0x0d, 0xae, 0xa8, 0x59,
+	0xb9, 0x47, 0x20, 0x86, 0xa4, 0x02, 0xb1, 0x89, 0xf6, 0xa1, 0x29, 0xcd, 0x13, 0x41, 0x8f, 0x8f,
+	0xfa, 0x7b, 0xa5, 0xf4, 0x93, 0x98, 0x9c, 0xa1, 0xd1, 0x00, 0x36, 0xa4, 0x71, 0x38, 0x0b, 0x3d,
+	0x77, 0x24, 0xfc, 0x5f, 0x95, 0xfc, 0x56, 0x29, 0x3f, 0x45, 0x0d, 0x34, 0xbc, 0xc0, 0x43, 0x2f,
+	0x00, 0x1c, 0xca, 0x89, 0xeb, 0xb1, 0x33, 0xca, 0x4d, 0x47, 0xaa, 0x58, 0x8b, 0x2a, 0x87, 0x29,
+	0x62, 0xa0, 0xe1, 0x1c, 0x1e, 0xf5, 0x61, 0x4d, 0x59, 0x6f, 0x7c, 0x46, 0xb9, 0x49, 0x25, 0x7f,
+	0x77, 0x09, 0x5f, 0x62, 0x06, 0x1a, 0x2e, 0x70, 0x44, 0x1e, 0x23, 0xea, 0x11, 0xee, 0x06, 0xfe,
+	0xd7, 0x8e, 0x63, 0x5e, 0x94, 0xe7, 0x11, 0x67, 0x10, 0x91, 0xc7, 0x1c, 0x43, 0x24, 0x23, 0x31,
+	0xd5, 0x5e, 0x8c, 0xcb, 0x93, 0x81, 0x0b, 0x28, 0x91, 0x8c, 0x22, 0x2f, 0xaf, 0xa4, 0x8e, 0xc5,
+	0xe4, 0x7e, 0xa5, 0xf4, 0x64, 0x2c, 0xf0, 0xd0, 0x11, 0xac, 0x07, 0xc3, 0xb7, 0x74, 0xc4, 0xbf,
+	0x9b, 0x87, 0x54, 0x84, 0xe5, 0x4a, 0xa1, 0x0f, 0x16, 0x85, 0x4e, 0xf3, 0xa0, 0x81, 0x86, 0x8b,
+	0x2c, 0xf4, 0x1a, 0x36, 0xb3, 0x01, 0x15, 0xdc, 0x5b, 0xa9, 0xd4, 0x5e, 0xae, 0x94, 0x86, 0x77,
+	0x87, 0x2b, 0x72, 0xcd, 0x78, 0x10, 0x89, 0xba, 0x14, 0xdb, 0x7d, 0x59, 0x9e, 0xeb, 0xb3, 0x0c,
+	0x22, 0x72, 0x9d, 0x63, 0x88, 0xb8, 0x12, 0x33, 0xde, 0x71, 0xaf, 0x3c, 0xae, 0xb3, 0x3c, 0x48,
+	0xc4, 0x55, 0x60, 0xf5, 0xeb, 0xaa, 0xc6, 0xad, 0x9f, 0x75, 0x30, 0x72, 0x45, 0x8a, 0x2c, 0x68,
+	0x70, 0x12, 0x8d, 0x29, 0x3f, 0x76, 0x54, 0x4f, 0x48, 0x6d, 0xb4, 0x0f, 0x8d, 0x30, 0x60, 0xae,
+	0xc8, 0xb2, 0x2c, 0xd7, 0x8d, 0xdc, 0xb2, 0x71, 0x0b, 0x95, 0x4a, 0xf6, 0xb7, 0x0a, 0x84, 0x53,
+	0x38, 0x7a, 0x02, 0x35, 0x79, 0xee, 0x93, 0xe6, 0xb9, 0x55, 0x46, 0xc4, 0x0a, 0x63, 0x7d, 0xa9,
+	0x7c, 0x52, 0x7b, 0x69, 0x43, 0x2d, 0xbe, 0x76, 0x55, 0xa7, 0xdb, 0x4e, 0xc9, 0x47, 0x62, 0xd8,
+	0x3e, 0xa1, 0x8c, 0x91, 0x31, 0xc5, 0x0a, 0x65, 0x7d, 0xa8, 0xe8, 0x2a, 0xe7, 0x9b, 0x50, 0xc9,
+	0xee, 0x5c, 0xf1, 0x69, 0x71, 0x68, 0xa6, 0x75, 0xfd, 0x6f, 0x45, 0xac, 0x56, 0xad, 0x64, 0xab,
+	0xce, 0x61, 0xa3, 0xd8, 0x0d, 0xfe, 0xbb, 0xa5, 0x5f, 0x01, 0x64, 0x2d, 0xa4, 0xa4, 0xe5, 0x3f,
+	0xc9, 0xb7, 0x7c, 0x91, 0xe0, 0xf8, 0x61, 0x63, 0x27, 0x0f, 0x1b, 0xfb, 0x7b, 0x31, 0xab, 0xae,
+	0x02, 0xab, 0x0d, 0x6b, 0xf9, 0x86, 0x72, 0x57, 0xcf, 0xea, 0x83, 0x91, 0xeb, 0x17, 0xe8, 0x29,
+	0x34, 0x92, 0xf2, 0x54, 0x2b, 0xec, 0x2c, 0xc4, 0x92, 0x76, 0x86, 0x14, 0x68, 0xfd, 0x5a, 0x81,
+	0x8d, 0x62, 0x99, 0x97, 0x38, 0xfe, 0x0c, 0x6a, 0x17, 0x41, 0x34, 0x25, 0x7c, 0x49, 0x8e, 0x12,
+	0x81, 0x97, 0x12, 0x34, 0xd0, 0xb0, 0x82, 0xa3, 0x2d, 0xa8, 0xfa, 0x64, 0x1a, 0xdf, 0x1a, 0xcd,
+	0x81, 0x86, 0xa5, 0x85, 0x5e, 0x88, 0x76, 0x7a, 0x41, 0x66, 0x1e, 0x97, 0x01, 0xab, 0x4b, 0x61,
+	0x49, 0x3a, 0xe2, 0x46, 0x9a, 0xa1, 0xd1, 0x6b, 0x30, 0xb2, 0x82, 0x67, 0xea, 0x46, 0x78, 0x7c,
+	0x7f, 0xeb, 0xca, 0xb5, 0x0d, 0x26, 0x6a, 0x3d, 0x27, 0x80, 0xb6, 0x61, 0x75, 0x3a, 0xf3, 0xb8,
+	0x6b, 0xd6, 0xda, 0x7a, 0xa7, 0x31, 0xd0, 0x70, 0x6c, 0xa2, 0x23, 0x00, 0x46, 0x3d, 0x3a, 0xe2,
+	0x87, 0xee, 0x88, 0xcb, 0x67, 0x93, 0xd1, 0x7b, 0xf8, 0x37, 0xcb, 0x08, 0xa8, 0xb8, 0x3b, 0x32,
+	0xa2, 0xf5, 0x1c, 0xaa, 0xe2, 0x1f, 0xf5, 0xa0, 0xea, 0x08, 0xa1, 0xb8, 0xb8, 0x5a, 0x4b, 0x32,
+	0x68, 0x9f, 0x86, 0x72, 0x83, 0x24, 0xd6, 0xea, 0x82, 0x91, 0x73, 0x1c, 0xb5, 0x8b, 0x91, 0xab,
+	0xe7, 0x6d, 0x6e, 0x28, 0x6b, 0x38, 0x7b, 0xd9, 0xae, 0x66, 0xf5, 0xb9, 0x70, 0x7c, 0x1e, 0xc0,
+	0x7a, 0xa1, 0x2f, 0x0b, 0xc8, 0x2c, 0xf2, 0x12, 0xc8, 0x2c, 0xf2, 0xac, 0x47, 0xb0, 0xb9, 0xd8,
+	0x70, 0x4b, 0x50, 0xa7, 0x60, 0xe4, 0x7a, 0xa9, 0x78, 0x44, 0x85, 0x84, 0x4f, 0x94, 0x7f, 0xf2,
+	0xfb, 0x1d, 0x8f, 0xfe, 0x43, 0x58, 0x2f, 0x74, 0xd6, 0x32, 0xc9, 0xfe, 0xee, 0x2f, 0x37, 0x2d,
+	0xfd, 0xfa, 0xa6, 0xa5, 0xff, 0x7e, 0xd3, 0xd2, 0x7f, 0xba, 0x6d, 0x69, 0xd7, 0xb7, 0x2d, 0xed,
+	0xb7, 0xdb, 0x96, 0xf6, 0xc3, 0x4a, 0x38, 0x1c, 0xd6, 0xa4, 0xf2, 0xd3, 0xbf, 0x02, 0x00, 0x00,
+	0xff, 0xff, 0x66, 0x05, 0x4d, 0x59, 0x9d, 0x0c, 0x00, 0x00,
 }
 
 func (m *Change) Marshal() (dAtA []byte, err error) {
@@ -1960,16 +1960,16 @@ func (m *ChangeContentValueOfObjectTypeRemove) MarshalToSizedBuffer(dAtA []byte)
 	}
 	return len(dAtA) - i, nil
 }
-func (m *ChangeContentValueOfCollectionKeySet) MarshalTo(dAtA []byte) (int, error) {
+func (m *ChangeContentValueOfStoreKeySet) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *ChangeContentValueOfCollectionKeySet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ChangeContentValueOfStoreKeySet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
-	if m.CollectionKeySet != nil {
+	if m.StoreKeySet != nil {
 		{
-			size, err := m.CollectionKeySet.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.StoreKeySet.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -1983,16 +1983,16 @@ func (m *ChangeContentValueOfCollectionKeySet) MarshalToSizedBuffer(dAtA []byte)
 	}
 	return len(dAtA) - i, nil
 }
-func (m *ChangeContentValueOfCollectionKeyUnset) MarshalTo(dAtA []byte) (int, error) {
+func (m *ChangeContentValueOfStoreKeyUnset) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *ChangeContentValueOfCollectionKeyUnset) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ChangeContentValueOfStoreKeyUnset) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
-	if m.CollectionKeyUnset != nil {
+	if m.StoreKeyUnset != nil {
 		{
-			size, err := m.CollectionKeyUnset.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.StoreKeyUnset.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -2623,7 +2623,7 @@ func (m *ChangeObjectTypeRemove) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	return len(dAtA) - i, nil
 }
 
-func (m *ChangeCollectionKeySet) Marshal() (dAtA []byte, err error) {
+func (m *ChangeStoreKeySet) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -2633,12 +2633,12 @@ func (m *ChangeCollectionKeySet) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *ChangeCollectionKeySet) MarshalTo(dAtA []byte) (int, error) {
+func (m *ChangeStoreKeySet) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *ChangeCollectionKeySet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ChangeStoreKeySet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -2655,11 +2655,11 @@ func (m *ChangeCollectionKeySet) MarshalToSizedBuffer(dAtA []byte) (int, error)
 		i--
 		dAtA[i] = 0x12
 	}
-	if len(m.Key) > 0 {
-		for iNdEx := len(m.Key) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Key[iNdEx])
-			copy(dAtA[i:], m.Key[iNdEx])
-			i = encodeVarintChanges(dAtA, i, uint64(len(m.Key[iNdEx])))
+	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
 		}
@@ -2667,7 +2667,7 @@ func (m *ChangeCollectionKeySet) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	return len(dAtA) - i, nil
 }
 
-func (m *ChangeCollectionKeyUnset) Marshal() (dAtA []byte, err error) {
+func (m *ChangeStoreKeyUnset) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -2677,21 +2677,21 @@ func (m *ChangeCollectionKeyUnset) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *ChangeCollectionKeyUnset) MarshalTo(dAtA []byte) (int, error) {
+func (m *ChangeStoreKeyUnset) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *ChangeCollectionKeyUnset) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ChangeStoreKeyUnset) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Key) > 0 {
-		for iNdEx := len(m.Key) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Key[iNdEx])
-			copy(dAtA[i:], m.Key[iNdEx])
-			i = encodeVarintChanges(dAtA, i, uint64(len(m.Key[iNdEx])))
+	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
 		}
@@ -2958,26 +2958,26 @@ func (m *ChangeContentValueOfObjectTypeRemove) Size() (n int) {
 	}
 	return n
 }
-func (m *ChangeContentValueOfCollectionKeySet) Size() (n int) {
+func (m *ChangeContentValueOfStoreKeySet) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.CollectionKeySet != nil {
-		l = m.CollectionKeySet.Size()
+	if m.StoreKeySet != nil {
+		l = m.StoreKeySet.Size()
 		n += 2 + l + sovChanges(uint64(l))
 	}
 	return n
 }
-func (m *ChangeContentValueOfCollectionKeyUnset) Size() (n int) {
+func (m *ChangeContentValueOfStoreKeyUnset) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.CollectionKeyUnset != nil {
-		l = m.CollectionKeyUnset.Size()
+	if m.StoreKeyUnset != nil {
+		l = m.StoreKeyUnset.Size()
 		n += 2 + l + sovChanges(uint64(l))
 	}
 	return n
@@ -3270,14 +3270,14 @@ func (m *ChangeObjectTypeRemove) Size() (n int) {
 	return n
 }
 
-func (m *ChangeCollectionKeySet) Size() (n int) {
+func (m *ChangeStoreKeySet) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.Key) > 0 {
-		for _, s := range m.Key {
+	if len(m.Path) > 0 {
+		for _, s := range m.Path {
 			l = len(s)
 			n += 1 + l + sovChanges(uint64(l))
 		}
@@ -3289,14 +3289,14 @@ func (m *ChangeCollectionKeySet) Size() (n int) {
 	return n
 }
 
-func (m *ChangeCollectionKeyUnset) Size() (n int) {
+func (m *ChangeStoreKeyUnset) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.Key) > 0 {
-		for _, s := range m.Key {
+	if len(m.Path) > 0 {
+		for _, s := range m.Path {
 			l = len(s)
 			n += 1 + l + sovChanges(uint64(l))
 		}
@@ -4486,7 +4486,7 @@ func (m *ChangeContent) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 107:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CollectionKeySet", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field StoreKeySet", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -4513,15 +4513,15 @@ func (m *ChangeContent) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			v := &ChangeCollectionKeySet{}
+			v := &ChangeStoreKeySet{}
 			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
-			m.Value = &ChangeContentValueOfCollectionKeySet{v}
+			m.Value = &ChangeContentValueOfStoreKeySet{v}
 			iNdEx = postIndex
 		case 108:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CollectionKeyUnset", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field StoreKeyUnset", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -4548,11 +4548,11 @@ func (m *ChangeContent) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			v := &ChangeCollectionKeyUnset{}
+			v := &ChangeStoreKeyUnset{}
 			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
-			m.Value = &ChangeContentValueOfCollectionKeyUnset{v}
+			m.Value = &ChangeContentValueOfStoreKeyUnset{v}
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -6100,7 +6100,7 @@ func (m *ChangeObjectTypeRemove) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ChangeCollectionKeySet) Unmarshal(dAtA []byte) error {
+func (m *ChangeStoreKeySet) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -6123,15 +6123,15 @@ func (m *ChangeCollectionKeySet) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: CollectionKeySet: wiretype end group for non-group")
+			return fmt.Errorf("proto: StoreKeySet: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: CollectionKeySet: illegal tag %d (wire type %d)", fieldNum, wire)
+			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 Key", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -6159,7 +6159,7 @@ func (m *ChangeCollectionKeySet) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Key = append(m.Key, string(dAtA[iNdEx:postIndex]))
+			m.Path = append(m.Path, string(dAtA[iNdEx:postIndex]))
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
@@ -6218,7 +6218,7 @@ func (m *ChangeCollectionKeySet) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ChangeCollectionKeyUnset) Unmarshal(dAtA []byte) error {
+func (m *ChangeStoreKeyUnset) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -6241,15 +6241,15 @@ func (m *ChangeCollectionKeyUnset) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: CollectionKeyUnset: wiretype end group for non-group")
+			return fmt.Errorf("proto: StoreKeyUnset: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: CollectionKeyUnset: illegal tag %d (wire type %d)", fieldNum, wire)
+			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 Key", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -6277,7 +6277,7 @@ func (m *ChangeCollectionKeyUnset) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Key = append(m.Key, string(dAtA[iNdEx:postIndex]))
+			m.Path = append(m.Path, string(dAtA[iNdEx:postIndex]))
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
diff --git a/pb/protos/changes.proto b/pb/protos/changes.proto
index 93dd90db8..f2ac5e952 100644
--- a/pb/protos/changes.proto
+++ b/pb/protos/changes.proto
@@ -51,8 +51,8 @@ message Change {
             RelationUpdate relationUpdate = 104;
             ObjectTypeAdd objectTypeAdd = 105;
             ObjectTypeRemove objectTypeRemove = 106;
-            CollectionKeySet collectionKeySet = 107;
-            CollectionKeyUnset collectionKeyUnset = 108;
+            StoreKeySet storeKeySet = 107;
+            StoreKeyUnset storeKeyUnset = 108;
 
         }
     }
@@ -128,12 +128,12 @@ message Change {
         string url = 1;
     }
 
-    message CollectionKeySet {
-        repeated string key = 1;
+    message StoreKeySet {
+        repeated string path = 1;
         google.protobuf.Value value = 2;
     }
 
-    message CollectionKeyUnset {
-        repeated string key = 1;
+    message StoreKeyUnset {
+        repeated string path = 1;
     }
 }