Repository: yorkie-team/yorkie
Pull request #318 (2022-05-02 07:16:18)

Remove Collection from Document
<!--  Thanks for sending a pull request! -->

**What this PR does / why we need it**:

Remove Collection from Document

We can use Project to separate documents and manage them.

For now, this commit removes Collection and it will be implemented when
the index or search function is strengthened in the future.

**Which issue(s) this PR fixes**:
<!--
*Automatically closes linked issue when PR is merged.
Usage: `Fixes #<issue number>`, or `Fixes (paste link of issue)`.
-->
Address #310

**Special notes for your reviewer**:

**Does this PR introduce a user-facing change?**:
<!--
If no, just write "NONE" in the release-note block below.
If yes, a release note is required:
Enter your extended release note in the block below. If the PR requires additional action from users switching to the new release, include the string "action required".
-->
```release-note

```

**Additional documentation**:

<!--
This section can be blank if this pull request does not require a release note.

Please use the following format for linking documentation:
- [Usage]: <link>
- [Other doc]: <link>
-->
```docs

```

**Checklist**:
- [ ] Added relevant tests or not required
- [ ] Didn't break anything


codecov[bot]: # [Codecov](https://codecov.io/gh/yorkie-team/yorkie/pull/318?src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team) Report
> Merging [#318](https://codecov.io/gh/yorkie-team/yorkie/pull/318?src=pr&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team) (cafac5c) into [main](https://codecov.io/gh/yorkie-team/yorkie/commit/d57f04cb888e6b6363a62cfd5e2493fdffeb4d2a?el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team) (d57f04c) will **decrease** coverage by `0.03%`.
> The diff coverage is `37.25%`.

```diff
@@            Coverage Diff             @@
##             main     #318      +/-   ##
==========================================
- Coverage   46.80%   46.76%   -0.04%     
==========================================
  Files          58       58              
  Lines        5072     5061      -11     
==========================================
- Hits         2374     2367       -7     
+ Misses       2443     2439       -4     
  Partials      255      255              
```


| [Impacted Files](https://codecov.io/gh/yorkie-team/yorkie/pull/318?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team) | Coverage Δ | |
|---|---|---|
| [client/client.go](https://codecov.io/gh/yorkie-team/yorkie/pull/318/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team#diff-Y2xpZW50L2NsaWVudC5nbw==) | `11.19% <0.00%> (ø)` | |
| [server/backend/db/doc\_info.go](https://codecov.io/gh/yorkie-team/yorkie/pull/318/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team#diff-c2VydmVyL2JhY2tlbmQvZGIvZG9jX2luZm8uZ28=) | `0.00% <0.00%> (ø)` | |
| [server/backend/db/mongo/client.go](https://codecov.io/gh/yorkie-team/yorkie/pull/318/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team#diff-c2VydmVyL2JhY2tlbmQvZGIvbW9uZ28vY2xpZW50Lmdv) | `0.00% <0.00%> (ø)` | |
| [server/backend/sync/etcd/pubsub.go](https://codecov.io/gh/yorkie-team/yorkie/pull/318/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team#diff-c2VydmVyL2JhY2tlbmQvc3luYy9ldGNkL3B1YnN1Yi5nbw==) | `0.00% <0.00%> (ø)` | |
| [server/rpc/yorkie\_server.go](https://codecov.io/gh/yorkie-team/yorkie/pull/318/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team#diff-c2VydmVyL3JwYy95b3JraWVfc2VydmVyLmdv) | `37.74% <0.00%> (ø)` | |
| [api/converter/to\_pb.go](https://codecov.io/gh/yorkie-team/yorkie/pull/318/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team#diff-YXBpL2NvbnZlcnRlci90b19wYi5nbw==) | `75.00% <20.00%> (-0.27%)` | :arrow_down: |
| [api/converter/from\_pb.go](https://codecov.io/gh/yorkie-team/yorkie/pull/318/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team#diff-YXBpL2NvbnZlcnRlci9mcm9tX3BiLmdv) | `61.28% <50.00%> (-0.28%)` | :arrow_down: |
| [server/backend/sync/memory/pubsub.go](https://codecov.io/gh/yorkie-team/yorkie/pull/318/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team#diff-c2VydmVyL2JhY2tlbmQvc3luYy9tZW1vcnkvcHVic3ViLmdv) | `45.45% <63.63%> (ø)` | |
| [server/backend/db/memory/db.go](https://codecov.io/gh/yorkie-team/yorkie/pull/318/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team#diff-c2VydmVyL2JhY2tlbmQvZGIvbWVtb3J5L2RiLmdv) | `45.92% <90.00%> (ø)` | |
| [pkg/document/document.go](https://codecov.io/gh/yorkie-team/yorkie/pull/318/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team#diff-cGtnL2RvY3VtZW50L2RvY3VtZW50Lmdv) | `56.06% <100.00%> (-0.66%)` | :arrow_down: |

------

[Continue to review full report at Codecov](https://codecov.io/gh/yorkie-team/yorkie/pull/318?src=pr&el=continue&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team).
> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team)
> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`
> Powered by [Codecov](https://codecov.io/gh/yorkie-team/yorkie/pull/318?src=pr&el=footer&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team). Last update [d57f04c...cafac5c](https://codecov.io/gh/yorkie-team/yorkie/pull/318?src=pr&el=lastupdated&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=yorkie-team).


Patch:
diff --git a/README.md b/README.md
index 6b59a4ae..84eedff4 100644
--- a/README.md
+++ b/README.md
@@ -19,7 +19,7 @@ Yorkie consists of three main components: Client, Document and Agent.
  ```
   Client "A" (Go)                 Server                       MemDB or MongoDB
 ┌───────────────────┐           ┌────────────────────────┐   ┌───────────┐
-│  Document "D-1"   │◄─Changes─►│  Collection "C-1"      │   │ Changes   │
+│  Document "D-1"   │◄─Changes─►│  Project "P-1"         │   │ Changes   │
 │  { a: 1, b: {} }  │           │ ┌───────────────────┐  │◄─►│ Snapshots │
 └───────────────────┘           │ │  Document "D-1"   │  │   └───────────┘
   Client "B" (JS)                │ │  { a: 2, b: {} }  │  │
@@ -30,7 +30,7 @@ Yorkie consists of three main components: Client, Document and Agent.
   Admin (CLI, Web)               │                        │
 ┌────────────────────┐          └────────────────────────┘
 │  Query "Q-1"       │              ▲
-│ db[c-1].find({a:2})├───DB Query───┘
+│  P-1.find({a:2})   ├───DB Query───┘
 └────────────────────┘
  ```
 
diff --git a/api/converter/from_pb.go b/api/converter/from_pb.go
index 4f7e823a..c6547281 100644
--- a/api/converter/from_pb.go
+++ b/api/converter/from_pb.go
@@ -103,7 +103,7 @@ func FromChangePack(pbPack *api.ChangePack) (*change.Pack, error) {
 	}
 
 	return &change.Pack{
-		DocumentKey:     FromDocumentKey(pbPack.DocumentKey),
+		DocumentKey:     key.Key(pbPack.DocumentKey),
 		Checkpoint:      fromCheckpoint(pbPack.Checkpoint),
 		Changes:         changes,
 		Snapshot:        pbPack.Snapshot,
@@ -111,14 +111,6 @@ func FromChangePack(pbPack *api.ChangePack) (*change.Pack, error) {
 	}, nil
 }
 
-// FromDocumentKey converts the given Protobuf formats to model format.
-func FromDocumentKey(pbKey *api.DocumentKey) key.Key {
-	return key.Key{
-		Collection: pbKey.Collection,
-		Document:   pbKey.Document,
-	}
-}
-
 func fromCheckpoint(pbCheckpoint *api.Checkpoint) change.Checkpoint {
 	return change.NewCheckpoint(
 		pbCheckpoint.ServerSeq,
@@ -162,10 +154,10 @@ func fromChangeID(id *api.ChangeID) (change.ID, error) {
 }
 
 // FromDocumentKeys converts the given Protobuf formats to model format.
-func FromDocumentKeys(pbKeys []*api.DocumentKey) []key.Key {
+func FromDocumentKeys(pbKeys []string) []key.Key {
 	var keys []key.Key
 	for _, pbKey := range pbKeys {
-		keys = append(keys, FromDocumentKey(pbKey))
+		keys = append(keys, key.Key(pbKey))
 	}
 	return keys
 }
diff --git a/api/converter/to_pb.go b/api/converter/to_pb.go
index a1c6d612..50e90108 100644
--- a/api/converter/to_pb.go
+++ b/api/converter/to_pb.go
@@ -70,7 +70,7 @@ func ToDocumentSummaries(summaries []*types.DocumentSummary) []*api.DocumentSumm
 	for _, summary := range summaries {
 		pbSummaries = append(pbSummaries, &api.DocumentSummary{
 			Id:       summary.ID,
-			Key:      ToDocumentKey(summary.Key),
+			Key:      summary.Key.String(),
 			Snapshot: summary.Snapshot,
 		})
 	}
@@ -101,7 +101,7 @@ func ToChangePack(pack *change.Pack) (*api.ChangePack, error) {
 	}
 
 	return &api.ChangePack{
-		DocumentKey:     ToDocumentKey(pack.DocumentKey),
+		DocumentKey:     pack.DocumentKey.String(),
 		Checkpoint:      ToCheckpoint(pack.Checkpoint),
 		Changes:         pbChanges,
 		Snapshot:        pack.Snapshot,
@@ -109,14 +109,6 @@ func ToChangePack(pack *change.Pack) (*api.ChangePack, error) {
 	}, nil
 }
 
-// ToDocumentKey converts the given model format to Protobuf format.
-func ToDocumentKey(key key.Key) *api.DocumentKey {
-	return &api.DocumentKey{
-		Collection: key.Collection,
-		Document:   key.Document,
-	}
-}
-
 // ToCheckpoint converts the given model format to Protobuf format.
 func ToCheckpoint(cp change.Checkpoint) *api.Checkpoint {
 	return &api.Checkpoint{
@@ -136,12 +128,12 @@ func ToChangeID(id change.ID) *api.ChangeID {
 }
 
 // ToDocumentKeys converts the given model format to Protobuf format.
-func ToDocumentKeys(keys []key.Key) []*api.DocumentKey {
-	var pbKeys []*api.DocumentKey
+func ToDocumentKeys(keys []key.Key) []string {
+	var keyList []string
 	for _, k := range keys {
-		pbKeys = append(pbKeys, ToDocumentKey(k))
+		keyList = append(keyList, k.String())
 	}
-	return pbKeys
+	return keyList
 }
 
 // ToClientsMap converts the given model to Protobuf format.
diff --git a/api/resources.pb.go b/api/resources.pb.go
index 0041acee..fdc6f722 100644
--- a/api/resources.pb.go
+++ b/api/resources.pb.go
@@ -119,14 +119,14 @@ func (DocEventType) EnumDescriptor() ([]byte, []int) {
 }
 
 type ChangePack struct {
-	DocumentKey          *DocumentKey `protobuf:"bytes,1,opt,name=document_key,json=documentKey,proto3" json:"document_key,omitempty"`
-	Checkpoint           *Checkpoint  `protobuf:"bytes,2,opt,name=checkpoint,proto3" json:"checkpoint,omitempty"`
-	Snapshot             []byte       `protobuf:"bytes,3,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
-	Changes              []*Change    `protobuf:"bytes,4,rep,name=changes,proto3" json:"changes,omitempty"`
-	MinSyncedTicket      *TimeTicket  `protobuf:"bytes,5,opt,name=min_synced_ticket,json=minSyncedTicket,proto3" json:"min_synced_ticket,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
+	DocumentKey          string      `protobuf:"bytes,1,opt,name=document_key,json=documentKey,proto3" json:"document_key,omitempty"`
+	Checkpoint           *Checkpoint `protobuf:"bytes,2,opt,name=checkpoint,proto3" json:"checkpoint,omitempty"`
+	Snapshot             []byte      `protobuf:"bytes,3,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
+	Changes              []*Change   `protobuf:"bytes,4,rep,name=changes,proto3" json:"changes,omitempty"`
+	MinSyncedTicket      *TimeTicket `protobuf:"bytes,5,opt,name=min_synced_ticket,json=minSyncedTicket,proto3" json:"min_synced_ticket,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
 }
 
 func (m *ChangePack) Reset()         { *m = ChangePack{} }
@@ -162,11 +162,11 @@ func (m *ChangePack) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_ChangePack proto.InternalMessageInfo
 
-func (m *ChangePack) GetDocumentKey() *DocumentKey {
+func (m *ChangePack) GetDocumentKey() string {
 	if m != nil {
 		return m.DocumentKey
 	}
-	return nil
+	return ""
 }
 
 func (m *ChangePack) GetCheckpoint() *Checkpoint {
@@ -2316,12 +2316,12 @@ func (m *Project) GetCreatedAt() *types.Timestamp {
 }
 
 type DocumentSummary struct {
-	Id                   string       `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
-	Key                  *DocumentKey `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
-	Snapshot             string       `protobuf:"bytes,3,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
+	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+	Key                  string   `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
+	Snapshot             string   `protobuf:"bytes,3,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *DocumentSummary) Reset()         { *m = DocumentSummary{} }
@@ -2364,11 +2364,11 @@ func (m *DocumentSummary) GetId() string {
 	return ""
 }
 
-func (m *DocumentSummary) GetKey() *DocumentKey {
+func (m *DocumentSummary) GetKey() string {
 	if m != nil {
 		return m.Key
 	}
-	return nil
+	return ""
 }
 
 func (m *DocumentSummary) GetSnapshot() string {
@@ -2535,61 +2535,6 @@ func (m *Clients) GetClients() []*Client {
 	return nil
 }
 
-type DocumentKey struct {
-	Collection           string   `protobuf:"bytes,1,opt,name=collection,proto3" json:"collection,omitempty"`
-	Document             string   `protobuf:"bytes,2,opt,name=document,proto3" json:"document,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *DocumentKey) Reset()         { *m = DocumentKey{} }
-func (m *DocumentKey) String() string { return proto.CompactTextString(m) }
-func (*DocumentKey) ProtoMessage()    {}
-func (*DocumentKey) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf1b13971fe4c19d, []int{17}
-}
-func (m *DocumentKey) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *DocumentKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_DocumentKey.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 *DocumentKey) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DocumentKey.Merge(m, src)
-}
-func (m *DocumentKey) XXX_Size() int {
-	return m.Size()
-}
-func (m *DocumentKey) XXX_DiscardUnknown() {
-	xxx_messageInfo_DocumentKey.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_DocumentKey proto.InternalMessageInfo
-
-func (m *DocumentKey) GetCollection() string {
-	if m != nil {
-		return m.Collection
-	}
-	return ""
-}
-
-func (m *DocumentKey) GetDocument() string {
-	if m != nil {
-		return m.Document
-	}
-	return ""
-}
-
 type Checkpoint struct {
 	ServerSeq            uint64   `protobuf:"varint,1,opt,name=server_seq,json=serverSeq,proto3" json:"server_seq,omitempty"`
 	ClientSeq            uint32   `protobuf:"varint,2,opt,name=client_seq,json=clientSeq,proto3" json:"client_seq,omitempty"`
@@ -2602,7 +2547,7 @@ func (m *Checkpoint) Reset()         { *m = Checkpoint{} }
 func (m *Checkpoint) String() string { return proto.CompactTextString(m) }
 func (*Checkpoint) ProtoMessage()    {}
 func (*Checkpoint) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf1b13971fe4c19d, []int{18}
+	return fileDescriptor_cf1b13971fe4c19d, []int{17}
 }
 func (m *Checkpoint) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2658,7 +2603,7 @@ func (m *TextNodePos) Reset()         { *m = TextNodePos{} }
 func (m *TextNodePos) String() string { return proto.CompactTextString(m) }
 func (*TextNodePos) ProtoMessage()    {}
 func (*TextNodePos) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf1b13971fe4c19d, []int{19}
+	return fileDescriptor_cf1b13971fe4c19d, []int{18}
 }
 func (m *TextNodePos) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2721,7 +2666,7 @@ func (m *TimeTicket) Reset()         { *m = TimeTicket{} }
 func (m *TimeTicket) String() string { return proto.CompactTextString(m) }
 func (*TimeTicket) ProtoMessage()    {}
 func (*TimeTicket) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf1b13971fe4c19d, []int{20}
+	return fileDescriptor_cf1b13971fe4c19d, []int{19}
 }
 func (m *TimeTicket) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2772,19 +2717,19 @@ func (m *TimeTicket) GetActorId() []byte {
 }
 
 type DocEvent struct {
-	Type                 DocEventType   `protobuf:"varint,1,opt,name=type,proto3,enum=api.DocEventType" json:"type,omitempty"`
-	Publisher            *Client        `protobuf:"bytes,2,opt,name=publisher,proto3" json:"publisher,omitempty"`
-	DocumentKeys         []*DocumentKey `protobuf:"bytes,3,rep,name=document_keys,json=documentKeys,proto3" json:"document_keys,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
-	XXX_unrecognized     []byte         `json:"-"`
-	XXX_sizecache        int32          `json:"-"`
+	Type                 DocEventType `protobuf:"varint,1,opt,name=type,proto3,enum=api.DocEventType" json:"type,omitempty"`
+	Publisher            *Client      `protobuf:"bytes,2,opt,name=publisher,proto3" json:"publisher,omitempty"`
+	DocumentKeys         []string     `protobuf:"bytes,3,rep,name=document_keys,json=documentKeys,proto3" json:"document_keys,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+	XXX_unrecognized     []byte       `json:"-"`
+	XXX_sizecache        int32        `json:"-"`
 }
 
 func (m *DocEvent) Reset()         { *m = DocEvent{} }
 func (m *DocEvent) String() string { return proto.CompactTextString(m) }
 func (*DocEvent) ProtoMessage()    {}
 func (*DocEvent) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf1b13971fe4c19d, []int{21}
+	return fileDescriptor_cf1b13971fe4c19d, []int{20}
 }
 func (m *DocEvent) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2827,7 +2772,7 @@ func (m *DocEvent) GetPublisher() *Client {
 	return nil
 }
 
-func (m *DocEvent) GetDocumentKeys() []*DocumentKey {
+func (m *DocEvent) GetDocumentKeys() []string {
 	if m != nil {
 		return m.DocumentKeys
 	}
@@ -2875,7 +2820,6 @@ func init() {
 	proto.RegisterMapType((map[string]string)(nil), "api.Metadata.DataEntry")
 	proto.RegisterType((*Client)(nil), "api.Client")
 	proto.RegisterType((*Clients)(nil), "api.Clients")
-	proto.RegisterType((*DocumentKey)(nil), "api.DocumentKey")
 	proto.RegisterType((*Checkpoint)(nil), "api.Checkpoint")
 	proto.RegisterType((*TextNodePos)(nil), "api.TextNodePos")
 	proto.RegisterType((*TimeTicket)(nil), "api.TimeTicket")
@@ -2885,139 +2829,136 @@ func init() {
 func init() { proto.RegisterFile("resources.proto", fileDescriptor_cf1b13971fe4c19d) }
 
 var fileDescriptor_cf1b13971fe4c19d = []byte{
-	// 2099 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x59, 0x4b, 0x6f, 0xe3, 0xc8,
-	0xf1, 0x17, 0x25, 0xea, 0xc1, 0x92, 0x6c, 0x73, 0x7a, 0x5e, 0x5a, 0xfd, 0x77, 0xbc, 0x5e, 0xfe,
-	0x77, 0x32, 0x8f, 0x1d, 0xd8, 0xc6, 0x6c, 0x36, 0xbb, 0xd9, 0x45, 0x02, 0xd0, 0x92, 0x60, 0x79,
-	0xd7, 0x96, 0x0c, 0x8a, 0xce, 0x64, 0x4f, 0x04, 0x4d, 0xb6, 0xc7, 0x1c, 0x4b, 0xa4, 0x86, 0x6c,
-	0x39, 0xa3, 0x4b, 0x0e, 0x01, 0x92, 0x43, 0xae, 0xc9, 0x21, 0xe7, 0x20, 0xc0, 0x7e, 0x81, 0x00,
-	0x39, 0x24, 0xc0, 0x1c, 0x72, 0xd9, 0xdb, 0x26, 0xc7, 0x20, 0x40, 0x10, 0x4c, 0xbe, 0x41, 0x3e,
-	0x41, 0xd0, 0x0f, 0x4a, 0xa4, 0x24, 0x8f, 0x46, 0xf0, 0x06, 0x6b, 0xe4, 0xc6, 0xee, 0xfa, 0x55,
-	0x57, 0x55, 0x57, 0x75, 0x57, 0x35, 0x0b, 0xd6, 0x42, 0x1c, 0x05, 0xc3, 0xd0, 0xc1, 0xd1, 0xe6,
-	0x20, 0x0c, 0x48, 0x80, 0x72, 0xf6, 0xc0, 0xab, 0xbd, 0xf3, 0x34, 0x08, 0x9e, 0xf6, 0xf0, 0x16,
-	0x9b, 0x3a, 0x1e, 0x9e, 0x6c, 0x11, 0xaf, 0x8f, 0x23, 0x62, 0xf7, 0x07, 0x1c, 0xa5, 0xfd, 0x5b,
-	0x02, 0xa8, 0x9f, 0xda, 0xfe, 0x53, 0x7c, 0x68, 0x3b, 0x67, 0xe8, 0x03, 0xa8, 0xb8, 0x81, 0x33,
-	0xec, 0x63, 0x9f, 0x58, 0x67, 0x78, 0x54, 0x95, 0x36, 0xa4, 0xfb, 0xe5, 0xc7, 0xea, 0xa6, 0x3d,
-	0xf0, 0x36, 0x1b, 0x82, 0xf0, 0x39, 0x1e, 0x19, 0x65, 0x77, 0x32, 0x40, 0x5b, 0x00, 0xce, 0x29,
-	0x76, 0xce, 0x06, 0x81, 0xe7, 0x93, 0x6a, 0x96, 0xb1, 0xac, 0x31, 0x96, 0xfa, 0x78, 0xda, 0x48,
-	0x40, 0x50, 0x0d, 0x4a, 0x91, 0x6f, 0x0f, 0xa2, 0xd3, 0x80, 0x54, 0x73, 0x1b, 0xd2, 0xfd, 0x8a,
-	0x31, 0x1e, 0xa3, 0xbb, 0x50, 0x74, 0x98, 0x3e, 0x51, 0x55, 0xde, 0xc8, 0xdd, 0x2f, 0x3f, 0x2e,
-	0x8b, 0x95, 0xe8, 0x9c, 0x11, 0xd3, 0xd0, 0xa7, 0x70, 0xad, 0xef, 0xf9, 0x56, 0x34, 0xf2, 0x1d,
-	0xec, 0x5a, 0xc4, 0x73, 0xce, 0x30, 0xa9, 0xe6, 0x13, 0xa2, 0x4d, 0xaf, 0x8f, 0x4d, 0x36, 0x6d,
-	0xac, 0xf5, 0x3d, 0xbf, 0xcb, 0x80, 0x7c, 0x42, 0x7b, 0x0e, 0x05, 0xbe, 0x1e, 0xba, 0x03, 0x59,
-	0xcf, 0x15, 0x56, 0xae, 0x24, 0x04, 0xed, 0x35, 0x8c, 0xac, 0xe7, 0xa2, 0x2a, 0x14, 0xfb, 0x38,
-	0x8a, 0xec, 0xa7, 0x98, 0x99, 0xa5, 0x18, 0xf1, 0x10, 0x6d, 0x02, 0x04, 0x03, 0x1c, 0xda, 0xc4,
-	0x0b, 0xfc, 0xa8, 0x9a, 0x63, 0x9a, 0xae, 0xb2, 0x05, 0x3a, 0xf1, 0xb4, 0x91, 0x40, 0x68, 0x3f,
-	0x97, 0xa0, 0x14, 0x2f, 0x8d, 0xee, 0x00, 0x38, 0x3d, 0x8f, 0xee, 0x71, 0x84, 0x9f, 0x33, 0xe9,
-	0x2b, 0x86, 0xc2, 0x67, 0xba, 0xf8, 0x39, 0x7a, 0x17, 0x20, 0xc2, 0xe1, 0x39, 0x0e, 0x19, 0x99,
-	0x0a, 0x96, 0x77, 0xb2, 0xdb, 0x92, 0xa1, 0xf0, 0x59, 0x0a, 0x79, 0x1b, 0x8a, 0x3d, 0xbb, 0x3f,
-	0x08, 0x42, 0xbe, 0x81, 0x9c, 0x1e, 0x4f, 0xa1, 0xb7, 0xa0, 0x64, 0x3b, 0x24, 0x08, 0x2d, 0xcf,
-	0xad, 0xca, 0x6c, 0x7f, 0x8b, 0x6c, 0xbc, 0xe7, 0x6a, 0x5f, 0xdd, 0x02, 0x65, 0xac, 0x21, 0xfa,
-	0x0e, 0xe4, 0x22, 0x4c, 0x84, 0xfd, 0x28, 0xad, 0xfe, 0x66, 0x17, 0x93, 0x56, 0xc6, 0xa0, 0x00,
-	0x8a, 0xb3, 0x5d, 0x57, 0xb8, 0x76, 0x1a, 0xa7, 0xbb, 0x2e, 0xc5, 0xd9, 0xae, 0x8b, 0x1e, 0x80,
-	0xdc, 0x0f, 0xce, 0x31, 0xd3, 0xa9, 0xfc, 0xf8, 0xfa, 0x14, 0xf0, 0x20, 0x38, 0xc7, 0xad, 0x8c,
-	0xc1, 0x20, 0x68, 0x0b, 0x0a, 0x21, 0x66, 0x60, 0x99, 0x81, 0x6f, 0x4e, 0x81, 0x0d, 0x46, 0x6c,
-	0x65, 0x0c, 0x01, 0xa3, 0x6b, 0x63, 0xd7, 0x8b, 0x9d, 0x3c, 0xbd, 0x76, 0xd3, 0xf5, 0xa8, 0xb6,
-	0x0c, 0x42, 0xd7, 0x8e, 0x70, 0x0f, 0x3b, 0xa4, 0x5a, 0x98, 0xbb, 0x76, 0x97, 0x11, 0xe9, 0xda,
-	0x1c, 0x86, 0xbe, 0x07, 0x4a, 0xe8, 0x39, 0xa7, 0x16, 0x13, 0x50, 0x64, 0x3c, 0xb7, 0xa7, 0xf5,
-	0xf1, 0x9c, 0x53, 0x21, 0xa4, 0x14, 0x8a, 0x6f, 0xf4, 0x08, 0xf2, 0x11, 0x19, 0xf5, 0x70, 0xb5,
-	0xc4, 0x78, 0x6e, 0x4c, 0xcb, 0xa1, 0xb4, 0x56, 0xc6, 0xe0, 0x20, 0xf4, 0x21, 0x94, 0x3c, 0xdf,
-	0x09, 0xb1, 0x1d, 0xe1, 0xaa, 0x32, 0x57, 0xc8, 0x9e, 0x20, 0x53, 0x21, 0x31, 0xb4, 0xf6, 0x7b,
-	0x09, 0x72, 0x5d, 0x4c, 0x68, 0xc8, 0x0f, 0xec, 0x90, 0x46, 0x0d, 0x25, 0x10, 0xec, 0x5a, 0x76,
-	0xec, 0xba, 0xd9, 0x90, 0xe7, 0xc8, 0x3a, 0x07, 0xea, 0x04, 0xa9, 0x90, 0xa3, 0xe7, 0x99, 0x47,
-	0x31, 0xfd, 0xa4, 0xba, 0x9f, 0xdb, 0xbd, 0x61, 0xec, 0xac, 0x5b, 0x6c, 0x89, 0xcf, 0xba, 0x9d,
-	0x76, 0xb3, 0x87, 0xe9, 0xc9, 0xee, 0x7a, 0xfd, 0x41, 0x0f, 0x1b, 0x1c, 0x84, 0xb6, 0xa1, 0x8c,
-	0x5f, 0x60, 0x67, 0x28, 0xc4, 0xca, 0xf3, 0xc5, 0x42, 0x8c, 0xd1, 0x49, 0xed, 0xef, 0x12, 0xe4,
-	0x74, 0xd7, 0xbd, 0x9c, 0xda, 0x1f, 0xc1, 0xda, 0x20, 0xc4, 0xe7, 0x49, 0xd6, 0xec, 0x7c, 0xd6,
-	0x15, 0x8a, 0x9b, 0x30, 0xfe, 0xb7, 0xad, 0xfb, 0x87, 0x04, 0x32, 0x8d, 0xe7, 0x6f, 0xc9, 0xbc,
-	0x4d, 0x80, 0x04, 0x4f, 0x6e, 0x3e, 0x8f, 0xe2, 0x8c, 0xf1, 0xcb, 0x1b, 0xf8, 0xa5, 0x04, 0x05,
-	0x7e, 0x06, 0x2f, 0x67, 0x62, 0x5a, 0xd3, 0xec, 0xb2, 0x9a, 0xe6, 0x16, 0x6b, 0xfa, 0xeb, 0x1c,
-	0xc8, 0xec, 0x34, 0x5e, 0x4a, 0xcf, 0xf7, 0x40, 0x3e, 0x09, 0x83, 0xbe, 0xd0, 0x90, 0x67, 0x3c,
-	0x13, 0xbf, 0x20, 0xed, 0xc0, 0xc5, 0x87, 0x41, 0x64, 0x30, 0x2a, 0xda, 0x80, 0x2c, 0x09, 0x84,
-	0x52, 0xb3, 0x98, 0x2c, 0x09, 0xd0, 0x31, 0xdc, 0x9e, 0x48, 0xb7, 0xfa, 0xf6, 0xc0, 0x3a, 0x1e,
-	0x59, 0xec, 0xf6, 0x15, 0xf9, 0xec, 0xd1, 0x9c, 0x9b, 0x6b, 0x73, 0xac, 0xc7, 0x81, 0x3d, 0xd8,
-	0x19, 0xe9, 0x14, 0xde, 0xf4, 0x49, 0x38, 0x32, 0xae, 0x3b, 0xb3, 0x14, 0x9a, 0x96, 0x9c, 0xc0,
-	0x27, 0xd8, 0xe7, 0xb7, 0xa1, 0x62, 0xc4, 0xc3, 0xe9, 0xdd, 0x2b, 0x2c, 0xde, 0xbd, 0x27, 0x50,
-	0xbd, 0x48, 0x78, 0x7c, 0x69, 0x48, 0x93, 0x4b, 0xe3, 0x6e, 0x7c, 0xac, 0x2e, 0x70, 0x24, 0xa7,
-	0x7e, 0x92, 0xfd, 0x58, 0xaa, 0xbd, 0x94, 0xa0, 0xc0, 0x2f, 0xda, 0xab, 0xe1, 0x98, 0xe5, 0x8f,
-	0xc0, 0xef, 0x64, 0x28, 0xc5, 0xd7, 0xfe, 0xd5, 0xb0, 0xe1, 0x64, 0x51, 0x70, 0x6d, 0x5f, 0x90,
-	0xb5, 0xbe, 0xb1, 0x00, 0xdb, 0x05, 0xb0, 0x09, 0x09, 0xbd, 0xe3, 0x21, 0xc1, 0x51, 0xb5, 0xc0,
-	0x84, 0xde, 0xbb, 0x48, 0xa8, 0x3e, 0x46, 0x72, 0x59, 0x09, 0xd6, 0x69, 0x77, 0x14, 0xbf, 0xc5,
-	0x48, 0xfd, 0x01, 0xac, 0x4d, 0x69, 0x3a, 0x67, 0xbd, 0x1b, 0xc9, 0xf5, 0x94, 0x24, 0xfb, 0x9f,
-	0xb3, 0x90, 0x67, 0x99, 0xfe, 0x6a, 0xc4, 0x48, 0x23, 0xe5, 0x21, 0x1e, 0x16, 0xef, 0xcd, 0x2b,
-	0x4c, 0x96, 0x71, 0x4f, 0x7e, 0xb1, 0x7b, 0x2e, 0xb9, 0x8b, 0x5f, 0x4a, 0x50, 0x8a, 0xcb, 0x9f,
-	0xcb, 0x6d, 0xe4, 0xa3, 0xb4, 0xe7, 0x97, 0x4b, 0xfd, 0x8b, 0xf3, 0xcd, 0x4e, 0x01, 0xe4, 0xe3,
-	0xc0, 0x1d, 0x69, 0x7f, 0x93, 0xe0, 0xda, 0xcc, 0xb2, 0x53, 0xf9, 0x4e, 0x5a, 0x98, 0xef, 0x1e,
-	0x42, 0x89, 0x26, 0xd9, 0xd7, 0x65, 0xc7, 0x22, 0x03, 0xf0, 0x5c, 0xca, 0x8b, 0xe1, 0xd7, 0x66,
-	0x7d, 0x01, 0xd1, 0x09, 0xd2, 0x40, 0x26, 0xa3, 0x01, 0xaf, 0xb0, 0x57, 0xc5, 0xf3, 0xe4, 0x47,
-	0xd4, 0x6a, 0x73, 0x34, 0xc0, 0x06, 0xa3, 0x4d, 0x3c, 0x92, 0x67, 0x0f, 0x05, 0x3e, 0xd0, 0x7e,
-	0x59, 0x81, 0x72, 0xc2, 0x36, 0xf4, 0x43, 0x28, 0x3f, 0x8b, 0x02, 0xdf, 0x0a, 0x8e, 0x9f, 0xd1,
-	0xb2, 0x9a, 0x9b, 0xf5, 0x7f, 0xd3, 0x3b, 0xcb, 0xbe, 0x3b, 0x0c, 0xd2, 0xca, 0x18, 0x40, 0x39,
-	0xf8, 0x08, 0x7d, 0x0a, 0x6c, 0x64, 0xd9, 0x61, 0x68, 0x8f, 0x84, 0x9d, 0xb5, 0xb9, 0xec, 0x3a,
-	0x45, 0xb4, 0x32, 0x86, 0x42, 0xf1, 0x6c, 0x80, 0x3e, 0x01, 0x65, 0x10, 0x7a, 0x7d, 0x8f, 0x78,
-	0xe3, 0xa7, 0xc5, 0x2c, 0xef, 0x61, 0x8c, 0xa0, 0xbc, 0x63, 0x38, 0x7a, 0x1f, 0x64, 0x82, 0x5f,
-	0x90, 0xd4, 0x23, 0x23, 0xc9, 0x46, 0x4f, 0x0f, 0x7d, 0x37, 0x50, 0x10, 0xfa, 0x58, 0x3c, 0x03,
-	0x18, 0x07, 0x0f, 0xf9, 0xb7, 0x66, 0x38, 0xe8, 0xed, 0x26, 0xb8, 0xd8, 0x43, 0x80, 0x7e, 0xa3,
-	0xef, 0xd2, 0x0b, 0x73, 0xe8, 0x13, 0x1c, 0x8a, 0x9c, 0x5b, 0x9d, 0xe1, 0xab, 0x73, 0x7a, 0x2b,
-	0x63, 0xc4, 0xd0, 0xda, 0x9f, 0x24, 0x80, 0xc9, 0x96, 0x21, 0x0d, 0xf2, 0x7e, 0xe0, 0xe2, 0xa8,
-	0x2a, 0xb1, 0x43, 0x5b, 0x61, 0x4b, 0x18, 0x2d, 0x93, 0x9e, 0x6e, 0x83, 0x93, 0x96, 0x2e, 0xa7,
-	0x92, 0xe1, 0x95, 0x5b, 0x2a, 0xbc, 0xe4, 0x45, 0xe1, 0x55, 0xfb, 0xa3, 0x04, 0xca, 0xd8, 0x65,
-	0x17, 0x68, 0xbf, 0xab, 0x5f, 0x55, 0xed, 0xff, 0x2a, 0x81, 0x32, 0x0e, 0x9a, 0xf1, 0x51, 0x91,
-	0xde, 0xe4, 0xa8, 0x64, 0x13, 0x47, 0x65, 0xe9, 0x52, 0x3c, 0x69, 0x93, 0xbc, 0x94, 0x4d, 0xf9,
-	0x85, 0x36, 0xfd, 0x41, 0x02, 0x99, 0xc5, 0xe3, 0xff, 0xa7, 0x9d, 0xb1, 0x92, 0xca, 0x14, 0x57,
-	0xd1, 0x1b, 0x2f, 0x25, 0x5e, 0x6b, 0x31, 0xed, 0xef, 0xa5, 0xb5, 0xbf, 0xc6, 0x43, 0x49, 0x50,
-	0xaf, 0xaa, 0x05, 0x5f, 0x4b, 0x50, 0x14, 0x67, 0xfc, 0x7f, 0x23, 0x9a, 0x68, 0xa2, 0xdb, 0xa1,
-	0x89, 0x6e, 0x17, 0x8a, 0xe2, 0x16, 0x9a, 0x93, 0xd1, 0x1f, 0x42, 0x11, 0xf3, 0x1b, 0x2e, 0x55,
-	0xb9, 0x24, 0x6e, 0x3e, 0x23, 0x06, 0x68, 0x4f, 0xa0, 0x28, 0x2e, 0x04, 0xb4, 0x01, 0xb2, 0x4f,
-	0x6f, 0x59, 0x9e, 0x49, 0xd2, 0x97, 0x05, 0xa3, 0x2c, 0xb5, 0xf0, 0x6f, 0x25, 0x28, 0xc5, 0xb1,
-	0x81, 0xde, 0x49, 0xfc, 0xd3, 0x5b, 0x4b, 0x05, 0xbe, 0xf8, 0xab, 0x37, 0xb7, 0x08, 0x59, 0x3a,
-	0xb9, 0x6e, 0x41, 0xd9, 0xf3, 0x23, 0x8b, 0xbd, 0xdf, 0xc5, 0x7f, 0xb6, 0x39, 0xf2, 0x14, 0xcf,
-	0x8f, 0x0e, 0x43, 0x7c, 0xbe, 0xe7, 0x6a, 0xcf, 0x40, 0x4d, 0xc6, 0x30, 0x2d, 0x96, 0xde, 0xb4,
-	0x42, 0xa2, 0xca, 0x0d, 0x07, 0xee, 0xa2, 0xb0, 0x10, 0x10, 0x9d, 0x68, 0x2f, 0xb3, 0x50, 0x49,
-	0x0a, 0x5b, 0xbc, 0x29, 0x7a, 0xaa, 0x6c, 0xcc, 0xb2, 0x83, 0xf7, 0xee, 0xcc, 0xc1, 0x7b, 0x6d,
-	0xcd, 0x78, 0x23, 0xf9, 0xcf, 0xe5, 0x82, 0x7d, 0x95, 0x97, 0xdd, 0xd7, 0xfc, 0xa2, 0x7d, 0xad,
-	0x99, 0x6f, 0x52, 0x78, 0xbe, 0x9f, 0x2e, 0x0a, 0x6f, 0xce, 0x58, 0x46, 0x97, 0x48, 0xd4, 0xa3,
-	0x9a, 0x09, 0x30, 0x11, 0xb7, 0x74, 0x55, 0x77, 0x0b, 0x0a, 0xc1, 0xc9, 0x49, 0x84, 0x79, 0xec,
-	0xe6, 0x0d, 0x31, 0xd2, 0x7e, 0x96, 0x85, 0xe2, 0x61, 0x18, 0xb0, 0x74, 0xbf, 0x3a, 0x76, 0x89,
-	0xc2, 0x3c, 0x80, 0x40, 0xf6, 0xed, 0x7e, 0xec, 0x78, 0xf6, 0x8d, 0xee, 0x00, 0x0c, 0x86, 0xc7,
-	0x3d, 0xcf, 0x61, 0x7f, 0xe3, 0xf9, 0xbe, 0x2a, 0x7c, 0xe6, 0x73, 0x3c, 0xa2, 0xe4, 0x08, 0x3b,
-	0x21, 0xe6, 0x3f, 0xeb, 0x65, 0x4e, 0xe6, 0x33, 0x94, 0x7c, 0x1f, 0x54, 0x7b, 0x48, 0x4e, 0xad,
-	0x9f, 0xe0, 0xe3, 0xd3, 0x20, 0x38, 0xb3, 0x86, 0x61, 0x4f, 0xbc, 0xe7, 0x56, 0xe9, 0xfc, 0x13,
-	0x3e, 0x7d, 0x14, 0xf6, 0xd0, 0x36, 0xdc, 0x48, 0x21, 0xfb, 0x98, 0x9c, 0x06, 0x2e, 0x7f, 0xe0,
-	0x29, 0x06, 0x4a, 0xa0, 0x0f, 0x38, 0x05, 0x7d, 0x3f, 0xb5, 0x23, 0x45, 0x51, 0x95, 0xf1, 0x76,
-	0xc3, 0x66, 0xdc, 0x6e, 0x60, 0xbb, 0xc3, 0xda, 0x0d, 0x89, 0xcd, 0xd1, 0x6c, 0x58, 0x8b, 0x7b,
-	0x09, 0xdd, 0x61, 0xbf, 0x6f, 0x87, 0xa3, 0x99, 0xbd, 0xd0, 0x26, 0xbf, 0x2b, 0xe7, 0xb5, 0x1f,
-	0x98, 0x4b, 0xa7, 0xbb, 0x08, 0xca, 0xa4, 0x8b, 0xa0, 0xfd, 0x42, 0x82, 0xd2, 0x01, 0x26, 0xb6,
-	0x6b, 0x13, 0x9b, 0xc6, 0xa5, 0xd3, 0x0b, 0x9c, 0x33, 0xb6, 0x7e, 0xde, 0xe0, 0x03, 0x5a, 0x19,
-	0x52, 0xaa, 0x08, 0x75, 0xfe, 0x27, 0x36, 0x66, 0xd9, 0x6c, 0xd8, 0xc4, 0xe6, 0x01, 0xce, 0x40,
-	0xb5, 0x8f, 0x40, 0x19, 0x4f, 0x2d, 0xf3, 0xac, 0xd1, 0xea, 0x50, 0xa8, 0xb3, 0x1f, 0xfb, 0x09,
-	0x13, 0x2b, 0xcc, 0xc4, 0x07, 0x50, 0xea, 0x0b, 0x71, 0xc2, 0xce, 0x95, 0x94, 0x0e, 0xc6, 0x98,
-	0xac, 0x6d, 0x43, 0x91, 0x2f, 0x12, 0xb1, 0xf6, 0x08, 0xff, 0x14, 0xc9, 0x51, 0xb4, 0x47, 0xd8,
-	0x9c, 0x11, 0xd3, 0xb4, 0x3d, 0x28, 0x27, 0xf6, 0x0b, 0xad, 0x03, 0x38, 0x41, 0xaf, 0x87, 0x1d,
-	0xfa, 0xfa, 0x13, 0x8a, 0x27, 0x66, 0xe8, 0x56, 0xc6, 0x0d, 0x1d, 0x61, 0xc2, 0x78, 0xac, 0xb5,
-	0x01, 0x26, 0x6d, 0x9c, 0xa9, 0xde, 0x84, 0x34, 0xaf, 0x37, 0x91, 0xee, 0x6e, 0x64, 0xa7, 0xba,
-	0x1b, 0xda, 0x4f, 0xa1, 0x9c, 0x78, 0xb2, 0x7e, 0x53, 0x27, 0x0b, 0xdd, 0x83, 0xb5, 0x10, 0xf7,
-	0x6c, 0x5a, 0xcc, 0x59, 0x02, 0x90, 0x63, 0x80, 0xd5, 0x78, 0xba, 0xc3, 0x8f, 0xa0, 0x03, 0x30,
-	0x59, 0x39, 0xd9, 0x48, 0x91, 0x66, 0x1b, 0x29, 0x6f, 0x83, 0xe2, 0xe2, 0x1e, 0xad, 0x11, 0x71,
-	0x18, 0x5b, 0x32, 0x9e, 0x48, 0xb5, 0x59, 0x72, 0xe9, 0x36, 0xcb, 0xaf, 0x24, 0x28, 0x35, 0x02,
-	0xa7, 0x79, 0x4e, 0x3d, 0x7f, 0x37, 0x55, 0x0d, 0x5c, 0x8b, 0xa3, 0x99, 0x11, 0x13, 0x05, 0xc1,
-	0x03, 0xe0, 0x27, 0x3b, 0x3a, 0x15, 0xc2, 0xa6, 0x9c, 0x3b, 0xa1, 0xa2, 0x0f, 0x61, 0x25, 0xd9,
-	0xa6, 0x8b, 0x1b, 0x50, 0xb3, 0x07, 0xa5, 0x92, 0xe8, 0xd3, 0x45, 0x0f, 0xbf, 0x96, 0x40, 0x19,
-	0x97, 0x21, 0xa8, 0x04, 0x72, 0xfb, 0x68, 0x7f, 0x5f, 0xcd, 0xa0, 0x32, 0x14, 0x77, 0x3a, 0x9d,
-	0xfd, 0xa6, 0xde, 0x56, 0x25, 0x3a, 0xd8, 0x6b, 0x9b, 0xcd, 0xdd, 0xa6, 0xa1, 0x66, 0x29, 0x66,
-	0xbf, 0xd3, 0xde, 0x55, 0x73, 0x08, 0xa0, 0xd0, 0xe8, 0x1c, 0xed, 0xec, 0x37, 0x55, 0x99, 0x7e,
-	0x77, 0x4d, 0x63, 0xaf, 0xbd, 0xab, 0xe6, 0x91, 0x02, 0xf9, 0x9d, 0x2f, 0xcc, 0x66, 0x57, 0x2d,
-	0x50, 0x70, 0x43, 0x37, 0x9b, 0x6a, 0x11, 0xad, 0xf1, 0xd7, 0xa3, 0xd5, 0xd9, 0xf9, 0xac, 0x59,
-	0x37, 0xd5, 0x12, 0x5a, 0xe5, 0x0f, 0x1d, 0x4b, 0x37, 0x0c, 0xfd, 0x0b, 0x55, 0xa1, 0x50, 0xb3,
-	0xf9, 0x63, 0x53, 0x05, 0xb4, 0x02, 0x8a, 0xb1, 0x57, 0x6f, 0x59, 0x6c, 0x58, 0xa6, 0x9c, 0x42,
-	0xba, 0x55, 0x6f, 0x9b, 0x6a, 0x05, 0x55, 0xa0, 0x44, 0x35, 0x60, 0xa3, 0x15, 0xba, 0x0e, 0xd7,
-	0x82, 0x8d, 0x57, 0x1f, 0x9e, 0x41, 0x25, 0xb9, 0x93, 0xe8, 0x26, 0x5c, 0x6b, 0x74, 0xea, 0x47,
-	0x07, 0xcd, 0xb6, 0xd9, 0xb5, 0xea, 0x2d, 0xbd, 0xbd, 0xdb, 0x6c, 0xa8, 0x99, 0xf4, 0xf4, 0x13,
-	0xdd, 0xac, 0xb7, 0x9a, 0x0d, 0x55, 0x42, 0xb7, 0xe1, 0xfa, 0x64, 0xfa, 0xa8, 0x1d, 0x13, 0xb2,
-	0xe8, 0x06, 0xa8, 0x07, 0x4d, 0x53, 0x6f, 0xe8, 0xa6, 0x3e, 0x5e, 0x25, 0xb7, 0xa3, 0x7e, 0xf5,
-	0x6a, 0x5d, 0xfa, 0xcb, 0xab, 0x75, 0xe9, 0x9f, 0xaf, 0xd6, 0xa5, 0xdf, 0xfc, 0x6b, 0x3d, 0x73,
-	0x5c, 0x60, 0x17, 0xdd, 0x07, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x1f, 0x8b, 0x77, 0x37, 0x7d,
-	0x1d, 0x00, 0x00,
+	// 2058 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x59, 0xcd, 0x6f, 0xdb, 0xc8,
+	0x15, 0x17, 0x25, 0xea, 0x83, 0x4f, 0xb2, 0xcd, 0x4c, 0x9c, 0x44, 0xab, 0x6e, 0xb2, 0x0e, 0x77,
+	0xd3, 0x38, 0xd9, 0xc0, 0x36, 0xd2, 0x8f, 0xdd, 0xee, 0xa2, 0x05, 0x68, 0x49, 0xb0, 0xbc, 0x6b,
+	0x4b, 0xc6, 0x48, 0x6e, 0xba, 0x27, 0x82, 0x26, 0xc7, 0x11, 0x63, 0x89, 0x54, 0xc8, 0x91, 0x1b,
+	0x5d, 0x0a, 0xb4, 0x40, 0x7b, 0xe8, 0xb9, 0x87, 0x9e, 0x8b, 0x02, 0xfb, 0x0f, 0x14, 0xe8, 0xa1,
+	0x05, 0x72, 0xe8, 0x65, 0x6f, 0xdb, 0x1e, 0x8b, 0x02, 0xc5, 0x22, 0xfd, 0x47, 0x8a, 0x99, 0x21,
+	0x25, 0x52, 0x92, 0xa3, 0x08, 0xde, 0x22, 0x46, 0x6f, 0x9c, 0x79, 0xbf, 0x79, 0x1f, 0xf3, 0xde,
+	0xcc, 0x7b, 0xc3, 0x07, 0x6b, 0x3e, 0x09, 0xbc, 0xa1, 0x6f, 0x91, 0x60, 0x6b, 0xe0, 0x7b, 0xd4,
+	0x43, 0x19, 0x73, 0xe0, 0x54, 0xde, 0x7b, 0xea, 0x79, 0x4f, 0x7b, 0x64, 0x9b, 0x4f, 0x9d, 0x0c,
+	0x4f, 0xb7, 0xa9, 0xd3, 0x27, 0x01, 0x35, 0xfb, 0x03, 0x81, 0xd2, 0xbe, 0x91, 0x00, 0xaa, 0x5d,
+	0xd3, 0x7d, 0x4a, 0x8e, 0x4c, 0xeb, 0x0c, 0xdd, 0x85, 0x92, 0xed, 0x59, 0xc3, 0x3e, 0x71, 0xa9,
+	0x71, 0x46, 0x46, 0x65, 0x69, 0x43, 0xda, 0x54, 0x70, 0x31, 0x9a, 0xfb, 0x9c, 0x8c, 0xd0, 0x36,
+	0x80, 0xd5, 0x25, 0xd6, 0xd9, 0xc0, 0x73, 0x5c, 0x5a, 0x4e, 0x6f, 0x48, 0x9b, 0xc5, 0xc7, 0x6b,
+	0x5b, 0xe6, 0xc0, 0xd9, 0xaa, 0x8e, 0xa7, 0x71, 0x0c, 0x82, 0x2a, 0x50, 0x08, 0x5c, 0x73, 0x10,
+	0x74, 0x3d, 0x5a, 0xce, 0x6c, 0x48, 0x9b, 0x25, 0x3c, 0x1e, 0xa3, 0x7b, 0x90, 0xb7, 0xb8, 0xf4,
+	0xa0, 0x2c, 0x6f, 0x64, 0x36, 0x8b, 0x8f, 0x8b, 0x21, 0x27, 0x36, 0x87, 0x23, 0x1a, 0xfa, 0x14,
+	0xae, 0xf5, 0x1d, 0xd7, 0x08, 0x46, 0xae, 0x45, 0x6c, 0x83, 0x3a, 0xd6, 0x19, 0xa1, 0xe5, 0x6c,
+	0x4c, 0x74, 0xc7, 0xe9, 0x93, 0x0e, 0x9f, 0xc6, 0x6b, 0x7d, 0xc7, 0x6d, 0x73, 0xa0, 0x98, 0xd0,
+	0x9e, 0x43, 0x4e, 0xf0, 0x43, 0xb7, 0x21, 0xed, 0xd8, 0xdc, 0xa6, 0xe2, 0xe3, 0x95, 0x98, 0xa0,
+	0xfd, 0x1a, 0x4e, 0x3b, 0x36, 0x2a, 0x43, 0xbe, 0x4f, 0x82, 0xc0, 0x7c, 0x4a, 0xb8, 0x59, 0x0a,
+	0x8e, 0x86, 0x68, 0x0b, 0xc0, 0x1b, 0x10, 0xdf, 0xa4, 0x8e, 0xe7, 0x06, 0xe5, 0x0c, 0xd7, 0x74,
+	0x95, 0x33, 0x68, 0x45, 0xd3, 0x38, 0x86, 0xd0, 0x7e, 0x2d, 0x41, 0x21, 0x62, 0x8d, 0x6e, 0x03,
+	0x58, 0x3d, 0x87, 0xed, 0x68, 0x40, 0x9e, 0x73, 0xe9, 0x2b, 0x58, 0x11, 0x33, 0x6d, 0xf2, 0x1c,
+	0xdd, 0x05, 0x08, 0x88, 0x7f, 0x4e, 0x7c, 0x4e, 0x66, 0x82, 0xe5, 0xdd, 0xf4, 0x8e, 0x84, 0x15,
+	0x31, 0xcb, 0x20, 0xef, 0x42, 0xbe, 0x67, 0xf6, 0x07, 0x9e, 0x2f, 0x36, 0x50, 0xd0, 0xa3, 0x29,
+	0xf4, 0x0e, 0x14, 0x4c, 0x8b, 0x7a, 0xbe, 0xe1, 0xd8, 0x65, 0x99, 0xef, 0x6f, 0x9e, 0x8f, 0xf7,
+	0x6d, 0xed, 0xab, 0x9b, 0xa0, 0x8c, 0x35, 0x44, 0xdf, 0x85, 0x4c, 0x40, 0x68, 0x68, 0x3f, 0x4a,
+	0xaa, 0xbf, 0xd5, 0x26, 0xb4, 0x91, 0xc2, 0x0c, 0xc0, 0x70, 0xa6, 0x6d, 0x87, 0xae, 0x9d, 0xc6,
+	0xe9, 0xb6, 0xcd, 0x70, 0xa6, 0x6d, 0xa3, 0x07, 0x20, 0xf7, 0xbd, 0x73, 0xc2, 0x75, 0x2a, 0x3e,
+	0xbe, 0x3e, 0x05, 0x3c, 0xf4, 0xce, 0x49, 0x23, 0x85, 0x39, 0x04, 0x6d, 0x43, 0xce, 0x27, 0x1c,
+	0x2c, 0x73, 0xf0, 0x8d, 0x29, 0x30, 0xe6, 0xc4, 0x46, 0x0a, 0x87, 0x30, 0xc6, 0x9b, 0xd8, 0x4e,
+	0xe4, 0xe4, 0x69, 0xde, 0x75, 0xdb, 0x61, 0xda, 0x72, 0x08, 0xe3, 0x1d, 0x90, 0x1e, 0xb1, 0x68,
+	0x39, 0x37, 0x97, 0x77, 0x9b, 0x13, 0x19, 0x6f, 0x01, 0x43, 0x3f, 0x04, 0xc5, 0x77, 0xac, 0xae,
+	0xc1, 0x05, 0xe4, 0xf9, 0x9a, 0x5b, 0xd3, 0xfa, 0x38, 0x56, 0x37, 0x14, 0x52, 0xf0, 0xc3, 0x6f,
+	0xf4, 0x08, 0xb2, 0x01, 0x1d, 0xf5, 0x48, 0xb9, 0xc0, 0xd7, 0xac, 0x4f, 0xcb, 0x61, 0xb4, 0x46,
+	0x0a, 0x0b, 0x10, 0xfa, 0x01, 0x14, 0x1c, 0xd7, 0xf2, 0x89, 0x19, 0x90, 0xb2, 0x32, 0x57, 0xc8,
+	0x7e, 0x48, 0x66, 0x42, 0x22, 0x68, 0xe5, 0x4f, 0x12, 0x64, 0xda, 0x84, 0xb2, 0x90, 0x1f, 0x98,
+	0x3e, 0x8b, 0x1a, 0x46, 0xa0, 0xc4, 0x36, 0xcc, 0xc8, 0x75, 0xb3, 0x21, 0x2f, 0x90, 0x55, 0x01,
+	0xd4, 0x29, 0x52, 0x21, 0xc3, 0x4e, 0xaf, 0x88, 0x62, 0xf6, 0xc9, 0x74, 0x3f, 0x37, 0x7b, 0xc3,
+	0xc8, 0x59, 0x37, 0x39, 0x8b, 0xcf, 0xda, 0xad, 0x66, 0xbd, 0x47, 0xd8, 0xc9, 0x6e, 0x3b, 0xfd,
+	0x41, 0x8f, 0x60, 0x01, 0x42, 0x3b, 0x50, 0x24, 0x2f, 0x88, 0x35, 0x0c, 0xc5, 0xca, 0xf3, 0xc5,
+	0x42, 0x84, 0xd1, 0x69, 0xe5, 0x5f, 0x12, 0x64, 0x74, 0xdb, 0xbe, 0x9c, 0xda, 0x1f, 0xc1, 0xda,
+	0xc0, 0x27, 0xe7, 0xf1, 0xa5, 0xe9, 0xf9, 0x4b, 0x57, 0x18, 0x6e, 0xb2, 0xf0, 0x7f, 0x6d, 0xdd,
+	0xbf, 0x25, 0x90, 0x59, 0x3c, 0xbf, 0x25, 0xf3, 0xb6, 0x00, 0x62, 0x6b, 0x32, 0xf3, 0xd7, 0x28,
+	0xd6, 0x18, 0xbf, 0xbc, 0x81, 0x5f, 0x4a, 0x90, 0x13, 0x67, 0xf0, 0x72, 0x26, 0x26, 0x35, 0x4d,
+	0x2f, 0xab, 0x69, 0x66, 0xb1, 0xa6, 0xbf, 0xcb, 0x80, 0xcc, 0x4f, 0xe3, 0xa5, 0xf4, 0xfc, 0x00,
+	0xe4, 0x53, 0xdf, 0xeb, 0x87, 0x1a, 0xaa, 0x02, 0x4f, 0x5e, 0xd0, 0xa6, 0x67, 0x93, 0x23, 0x2f,
+	0xc0, 0x9c, 0x8a, 0x36, 0x20, 0x4d, 0xbd, 0x50, 0xa9, 0x59, 0x4c, 0x9a, 0x7a, 0xe8, 0x04, 0x6e,
+	0x4d, 0xa4, 0x1b, 0x7d, 0x73, 0x60, 0x9c, 0x8c, 0x0c, 0x7e, 0xfb, 0x86, 0xf9, 0xec, 0xd1, 0x9c,
+	0x9b, 0x6b, 0x6b, 0xac, 0xc7, 0xa1, 0x39, 0xd8, 0x1d, 0xe9, 0x0c, 0x5e, 0x77, 0xa9, 0x3f, 0xc2,
+	0xd7, 0xad, 0x59, 0x0a, 0x4b, 0x4b, 0x96, 0xe7, 0x52, 0xe2, 0x8a, 0xdb, 0x50, 0xc1, 0xd1, 0x70,
+	0x7a, 0xf7, 0x72, 0x8b, 0x77, 0xef, 0x09, 0x94, 0x2f, 0x12, 0x1e, 0x5d, 0x1a, 0xd2, 0xe4, 0xd2,
+	0xb8, 0x17, 0x1d, 0xab, 0x0b, 0x1c, 0x29, 0xa8, 0x9f, 0xa4, 0x3f, 0x96, 0x2a, 0x2f, 0x25, 0xc8,
+	0x89, 0x8b, 0xf6, 0x6a, 0x38, 0x66, 0xf9, 0x23, 0xf0, 0x47, 0x19, 0x0a, 0xd1, 0xb5, 0x7f, 0x35,
+	0x6c, 0x38, 0x5d, 0x14, 0x5c, 0x3b, 0x17, 0x64, 0xad, 0x6f, 0x2d, 0xc0, 0xf6, 0x00, 0x4c, 0x4a,
+	0x7d, 0xe7, 0x64, 0x48, 0x49, 0x50, 0xce, 0x71, 0xa1, 0xf7, 0x2f, 0x12, 0xaa, 0x8f, 0x91, 0x42,
+	0x56, 0x6c, 0xe9, 0xb4, 0x3b, 0xf2, 0x6f, 0x31, 0x52, 0x7f, 0x0c, 0x6b, 0x53, 0x9a, 0xce, 0xe1,
+	0xb7, 0x1e, 0xe7, 0xa7, 0xc4, 0x97, 0xff, 0x2d, 0x0d, 0x59, 0x9e, 0xe9, 0xaf, 0x46, 0x8c, 0xd4,
+	0x12, 0x1e, 0x12, 0x61, 0xf1, 0xc1, 0xbc, 0xc2, 0x64, 0x19, 0xf7, 0x64, 0x17, 0xbb, 0xe7, 0x92,
+	0xbb, 0xf8, 0xa5, 0x04, 0x85, 0xa8, 0xfc, 0xb9, 0xdc, 0x46, 0x3e, 0x4a, 0x7a, 0x7e, 0xb9, 0xd4,
+	0xbf, 0x38, 0xdf, 0xec, 0xe6, 0x40, 0x3e, 0xf1, 0xec, 0x91, 0xf6, 0x4f, 0x09, 0xae, 0xcd, 0xb0,
+	0x9d, 0xca, 0x77, 0xd2, 0xc2, 0x7c, 0xf7, 0x10, 0x0a, 0x2c, 0xc9, 0xbe, 0x2e, 0x3b, 0xe6, 0x39,
+	0x40, 0xe4, 0x52, 0x51, 0x0c, 0xbf, 0x36, 0xeb, 0x87, 0x10, 0x9d, 0x22, 0x0d, 0x64, 0x3a, 0x1a,
+	0x88, 0x0a, 0x7b, 0x35, 0x7c, 0x9e, 0xfc, 0x94, 0x59, 0xdd, 0x19, 0x0d, 0x08, 0xe6, 0xb4, 0x89,
+	0x47, 0xb2, 0xfc, 0xa1, 0x20, 0x06, 0xda, 0x6f, 0x4b, 0x50, 0x8c, 0xd9, 0x86, 0x7e, 0x02, 0xc5,
+	0x67, 0x81, 0xe7, 0x1a, 0xde, 0xc9, 0x33, 0x56, 0x56, 0x0b, 0xb3, 0xbe, 0x33, 0xbd, 0xb3, 0xfc,
+	0xbb, 0xc5, 0x21, 0x8d, 0x14, 0x06, 0xb6, 0x42, 0x8c, 0xd0, 0xa7, 0xc0, 0x47, 0x86, 0xe9, 0xfb,
+	0xe6, 0x28, 0xb4, 0xb3, 0x32, 0x77, 0xb9, 0xce, 0x10, 0x8d, 0x14, 0x56, 0x18, 0x9e, 0x0f, 0xd0,
+	0x27, 0xa0, 0x0c, 0x7c, 0xa7, 0xef, 0x50, 0x67, 0xfc, 0xb4, 0x98, 0x5d, 0x7b, 0x14, 0x21, 0xd8,
+	0xda, 0x31, 0x1c, 0x7d, 0x08, 0x32, 0x25, 0x2f, 0x68, 0xe2, 0x91, 0x11, 0x5f, 0xc6, 0x4e, 0x0f,
+	0x7b, 0x37, 0x30, 0x10, 0xfa, 0x38, 0x7c, 0x06, 0xf0, 0x15, 0x22, 0xe4, 0xdf, 0x99, 0x59, 0xc1,
+	0x6e, 0xb7, 0x70, 0x15, 0x7f, 0x08, 0xb0, 0x6f, 0xf4, 0x7d, 0x76, 0x61, 0x0e, 0x5d, 0x4a, 0xfc,
+	0x30, 0xe7, 0x96, 0x67, 0xd6, 0x55, 0x05, 0xbd, 0x91, 0xc2, 0x11, 0xb4, 0xf2, 0x57, 0x09, 0x60,
+	0xb2, 0x65, 0x48, 0x83, 0xac, 0xeb, 0xd9, 0x24, 0x28, 0x4b, 0xfc, 0xd0, 0x96, 0x38, 0x0b, 0xdc,
+	0xe8, 0xb0, 0xd3, 0x8d, 0x05, 0x69, 0xe9, 0x72, 0x2a, 0x1e, 0x5e, 0x99, 0xa5, 0xc2, 0x4b, 0x5e,
+	0x14, 0x5e, 0x95, 0xbf, 0x48, 0xa0, 0x8c, 0x5d, 0x76, 0x81, 0xf6, 0x7b, 0xfa, 0x55, 0xd5, 0xfe,
+	0x1f, 0x12, 0x28, 0xe3, 0xa0, 0x19, 0x1f, 0x15, 0xe9, 0x4d, 0x8e, 0x4a, 0x3a, 0x76, 0x54, 0x96,
+	0x2e, 0xc5, 0xe3, 0x36, 0xc9, 0x4b, 0xd9, 0x94, 0x5d, 0x68, 0xd3, 0x9f, 0x25, 0x90, 0x79, 0x3c,
+	0xbe, 0x9f, 0x74, 0xc6, 0x4a, 0x22, 0x53, 0x5c, 0x45, 0x6f, 0xbc, 0x94, 0x44, 0xad, 0xc5, 0xb5,
+	0xbf, 0x9f, 0xd4, 0xfe, 0x9a, 0x08, 0xa5, 0x90, 0x7a, 0x55, 0x2d, 0xf8, 0x5a, 0x82, 0x7c, 0x78,
+	0xc6, 0xff, 0x3f, 0xa2, 0x89, 0x25, 0xba, 0x5d, 0x96, 0xe8, 0xf6, 0x20, 0x1f, 0xde, 0x42, 0x73,
+	0x32, 0xfa, 0x43, 0xc8, 0x13, 0x71, 0xc3, 0x25, 0x2a, 0x97, 0xd8, 0xcd, 0x87, 0x23, 0x80, 0xf6,
+	0x04, 0xf2, 0xe1, 0x85, 0x80, 0x36, 0x40, 0x76, 0xd9, 0x2d, 0x2b, 0x32, 0x49, 0xf2, 0xb2, 0xe0,
+	0x94, 0xa5, 0x18, 0xff, 0x41, 0x82, 0x42, 0x14, 0x1b, 0xe8, 0xbd, 0xd8, 0x3f, 0xbd, 0xb5, 0x44,
+	0xe0, 0x87, 0x7f, 0xf5, 0xe6, 0x16, 0x21, 0x4b, 0x27, 0xd7, 0x6d, 0x28, 0x3a, 0x6e, 0x60, 0xf0,
+	0xf7, 0x7b, 0xf8, 0x9f, 0x6d, 0x8e, 0x3c, 0xc5, 0x71, 0x83, 0x23, 0x9f, 0x9c, 0xef, 0xdb, 0xda,
+	0x33, 0x50, 0xe3, 0x31, 0xcc, 0x8a, 0xa5, 0x37, 0xad, 0x90, 0x98, 0x72, 0xc3, 0x81, 0xbd, 0x28,
+	0x2c, 0x42, 0x88, 0x4e, 0xb5, 0x97, 0x69, 0x28, 0xc5, 0x85, 0x2d, 0xde, 0x14, 0x3d, 0x51, 0x36,
+	0xa6, 0xf9, 0xc1, 0xbb, 0x3b, 0x73, 0xf0, 0x5e, 0x5b, 0x33, 0xae, 0xc7, 0xff, 0xb9, 0x5c, 0xb0,
+	0xaf, 0xf2, 0xb2, 0xfb, 0x9a, 0x5d, 0xb4, 0xaf, 0x95, 0xce, 0x9b, 0x14, 0x9e, 0x1f, 0x26, 0x8b,
+	0xc2, 0x1b, 0x33, 0x96, 0x31, 0x16, 0xb1, 0x7a, 0x54, 0xeb, 0x00, 0x4c, 0xc4, 0x2d, 0x5d, 0xd5,
+	0xdd, 0x84, 0x9c, 0x77, 0x7a, 0x1a, 0x10, 0x11, 0xbb, 0x59, 0x1c, 0x8e, 0xb4, 0x5f, 0xa5, 0x21,
+	0x7f, 0xe4, 0x7b, 0x3c, 0xdd, 0xaf, 0x8e, 0x5d, 0xa2, 0x70, 0x0f, 0x20, 0x90, 0x5d, 0xb3, 0x1f,
+	0x39, 0x9e, 0x7f, 0xa3, 0xdb, 0x00, 0x83, 0xe1, 0x49, 0xcf, 0xb1, 0xf8, 0xbf, 0x77, 0xb1, 0xaf,
+	0x8a, 0x98, 0xf9, 0x9c, 0x8c, 0x18, 0x39, 0x20, 0x96, 0x4f, 0xc4, 0xaf, 0x79, 0x59, 0x90, 0xc5,
+	0x0c, 0x23, 0x6f, 0x82, 0x6a, 0x0e, 0x69, 0xd7, 0xf8, 0x39, 0x39, 0xe9, 0x7a, 0xde, 0x99, 0x31,
+	0xf4, 0x7b, 0xe1, 0x7b, 0x6e, 0x95, 0xcd, 0x3f, 0x11, 0xd3, 0xc7, 0x7e, 0x0f, 0xed, 0xc0, 0x7a,
+	0x02, 0xd9, 0x27, 0xb4, 0xeb, 0xd9, 0xe2, 0x81, 0xa7, 0x60, 0x14, 0x43, 0x1f, 0x0a, 0x0a, 0xfa,
+	0x51, 0x62, 0x47, 0xf2, 0x61, 0x55, 0x26, 0x9a, 0x0b, 0x5b, 0x51, 0x73, 0x81, 0xef, 0x0e, 0x6f,
+	0x2e, 0xc4, 0x36, 0x47, 0x6b, 0xc1, 0x5a, 0x2d, 0x6c, 0x1f, 0xb4, 0x87, 0xfd, 0xbe, 0xe9, 0x8f,
+	0x66, 0xf6, 0x62, 0xf6, 0x77, 0xe5, 0x74, 0xcf, 0x40, 0x99, 0xf4, 0x0c, 0xb4, 0xdf, 0x48, 0x50,
+	0x38, 0x24, 0xd4, 0xb4, 0x4d, 0x6a, 0xb2, 0x28, 0xb4, 0x7a, 0x9e, 0x75, 0xc6, 0xb9, 0x65, 0xb1,
+	0x18, 0xb0, 0x3a, 0x90, 0x51, 0xc3, 0xc0, 0x16, 0xff, 0x5d, 0xa3, 0x25, 0x5b, 0x35, 0x93, 0x9a,
+	0x22, 0x9c, 0x39, 0xa8, 0xf2, 0x11, 0x28, 0xe3, 0xa9, 0x65, 0x1e, 0x31, 0x5a, 0x15, 0x72, 0x55,
+	0xfe, 0x1b, 0x3f, 0x66, 0x50, 0x89, 0x1b, 0xf4, 0x00, 0x0a, 0xfd, 0x50, 0x5c, 0x18, 0x82, 0x2b,
+	0x09, 0x1d, 0xf0, 0x98, 0xac, 0xed, 0x40, 0x5e, 0x30, 0x09, 0x78, 0x33, 0x44, 0x7c, 0x86, 0xa9,
+	0x30, 0x6c, 0x86, 0xf0, 0x39, 0x1c, 0xd1, 0xb4, 0x26, 0xc0, 0xa4, 0xd3, 0x32, 0xd5, 0x3e, 0x90,
+	0xe6, 0xb5, 0x0f, 0x92, 0x0d, 0x88, 0xf4, 0x54, 0x03, 0x42, 0xfb, 0x05, 0x14, 0x63, 0xaf, 0xca,
+	0x6f, 0x2b, 0xf8, 0xd1, 0x7d, 0x58, 0xf3, 0x49, 0xcf, 0x64, 0xf5, 0x96, 0x11, 0x02, 0x32, 0x1c,
+	0xb0, 0x1a, 0x4d, 0xb7, 0xc4, 0x29, 0xb1, 0x00, 0x26, 0x9c, 0xe3, 0xbd, 0x0e, 0x69, 0xb6, 0xd7,
+	0xf1, 0x2e, 0x28, 0x36, 0xe9, 0xb1, 0x32, 0x8e, 0xf8, 0x91, 0x25, 0xe3, 0x89, 0x44, 0x27, 0x24,
+	0x93, 0xec, 0x84, 0xfc, 0x52, 0x82, 0x42, 0xcd, 0xb3, 0xea, 0xe7, 0xcc, 0x5d, 0xf7, 0x12, 0x09,
+	0x5b, 0x14, 0x1c, 0x11, 0x31, 0x96, 0xb3, 0x1f, 0x80, 0x38, 0x7c, 0x41, 0x37, 0x14, 0x36, 0xe5,
+	0x91, 0x09, 0x15, 0xbd, 0x0f, 0x2b, 0xf1, 0xbe, 0x99, 0xe8, 0x11, 0x29, 0xb8, 0x14, 0x6b, 0x9c,
+	0x05, 0x0f, 0xbf, 0x96, 0x40, 0x19, 0xd7, 0x05, 0xa8, 0x00, 0x72, 0xf3, 0xf8, 0xe0, 0x40, 0x4d,
+	0xa1, 0x22, 0xe4, 0x77, 0x5b, 0xad, 0x83, 0xba, 0xde, 0x54, 0x25, 0x36, 0xd8, 0x6f, 0x76, 0xea,
+	0x7b, 0x75, 0xac, 0xa6, 0x19, 0xe6, 0xa0, 0xd5, 0xdc, 0x53, 0x33, 0x08, 0x20, 0x57, 0x6b, 0x1d,
+	0xef, 0x1e, 0xd4, 0x55, 0x99, 0x7d, 0xb7, 0x3b, 0x78, 0xbf, 0xb9, 0xa7, 0x66, 0x91, 0x02, 0xd9,
+	0xdd, 0x2f, 0x3a, 0xf5, 0xb6, 0x9a, 0x63, 0xe0, 0x9a, 0xde, 0xa9, 0xab, 0x79, 0xb4, 0x26, 0x9e,
+	0x73, 0x46, 0x6b, 0xf7, 0xb3, 0x7a, 0xb5, 0xa3, 0x16, 0xd0, 0xaa, 0x78, 0x79, 0x18, 0x3a, 0xc6,
+	0xfa, 0x17, 0xaa, 0xc2, 0xa0, 0x9d, 0xfa, 0xcf, 0x3a, 0x2a, 0xa0, 0x15, 0x50, 0xf0, 0x7e, 0xb5,
+	0x61, 0xf0, 0x61, 0x91, 0xad, 0x0c, 0xa5, 0x1b, 0xd5, 0x66, 0x47, 0x2d, 0xa1, 0x12, 0x14, 0x98,
+	0x06, 0x7c, 0xb4, 0xc2, 0xf8, 0x08, 0x2d, 0xf8, 0x78, 0xf5, 0xe1, 0x19, 0x94, 0xe2, 0xfb, 0x86,
+	0x6e, 0xc0, 0xb5, 0x5a, 0xab, 0x7a, 0x7c, 0x58, 0x6f, 0x76, 0xda, 0x46, 0xb5, 0xa1, 0x37, 0xf7,
+	0xea, 0x35, 0x35, 0x95, 0x9c, 0x7e, 0xa2, 0x77, 0xaa, 0x8d, 0x7a, 0x4d, 0x95, 0xd0, 0x2d, 0xb8,
+	0x3e, 0x99, 0x3e, 0x6e, 0x46, 0x84, 0x34, 0x5a, 0x07, 0xf5, 0xb0, 0xde, 0xd1, 0x6b, 0x7a, 0x47,
+	0x1f, 0x73, 0xc9, 0xec, 0xaa, 0x5f, 0xbd, 0xba, 0x23, 0xfd, 0xfd, 0xd5, 0x1d, 0xe9, 0x9b, 0x57,
+	0x77, 0xa4, 0xdf, 0xff, 0xe7, 0x4e, 0xea, 0x24, 0xc7, 0x6f, 0x9e, 0xef, 0xfd, 0x37, 0x00, 0x00,
+	0xff, 0xff, 0x2b, 0xd8, 0x0b, 0x9b, 0xfc, 0x1c, 0x00, 0x00,
 }
 
 func (m *ChangePack) Marshal() (dAtA []byte, err error) {
@@ -3089,15 +3030,10 @@ func (m *ChangePack) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x12
 	}
-	if m.DocumentKey != nil {
-		{
-			size, err := m.DocumentKey.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintResources(dAtA, i, uint64(size))
-		}
+	if len(m.DocumentKey) > 0 {
+		i -= len(m.DocumentKey)
+		copy(dAtA[i:], m.DocumentKey)
+		i = encodeVarintResources(dAtA, i, uint64(len(m.DocumentKey)))
 		i--
 		dAtA[i] = 0xa
 	}
@@ -5357,15 +5293,10 @@ func (m *DocumentSummary) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x1a
 	}
-	if m.Key != nil {
-		{
-			size, err := m.Key.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintResources(dAtA, i, uint64(size))
-		}
+	if len(m.Key) > 0 {
+		i -= len(m.Key)
+		copy(dAtA[i:], m.Key)
+		i = encodeVarintResources(dAtA, i, uint64(len(m.Key)))
 		i--
 		dAtA[i] = 0x12
 	}
@@ -5517,47 +5448,6 @@ func (m *Clients) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *DocumentKey) 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 *DocumentKey) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *DocumentKey) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.Document) > 0 {
-		i -= len(m.Document)
-		copy(dAtA[i:], m.Document)
-		i = encodeVarintResources(dAtA, i, uint64(len(m.Document)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.Collection) > 0 {
-		i -= len(m.Collection)
-		copy(dAtA[i:], m.Collection)
-		i = encodeVarintResources(dAtA, i, uint64(len(m.Collection)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
 func (m *Checkpoint) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -5714,14 +5604,9 @@ func (m *DocEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	}
 	if len(m.DocumentKeys) > 0 {
 		for iNdEx := len(m.DocumentKeys) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.DocumentKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintResources(dAtA, i, uint64(size))
-			}
+			i -= len(m.DocumentKeys[iNdEx])
+			copy(dAtA[i:], m.DocumentKeys[iNdEx])
+			i = encodeVarintResources(dAtA, i, uint64(len(m.DocumentKeys[iNdEx])))
 			i--
 			dAtA[i] = 0x1a
 		}
@@ -5763,8 +5648,8 @@ func (m *ChangePack) Size() (n int) {
 	}
 	var l int
 	_ = l
-	if m.DocumentKey != nil {
-		l = m.DocumentKey.Size()
+	l = len(m.DocumentKey)
+	if l > 0 {
 		n += 1 + l + sovResources(uint64(l))
 	}
 	if m.Checkpoint != nil {
@@ -6763,8 +6648,8 @@ func (m *DocumentSummary) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovResources(uint64(l))
 	}
-	if m.Key != nil {
-		l = m.Key.Size()
+	l = len(m.Key)
+	if l > 0 {
 		n += 1 + l + sovResources(uint64(l))
 	}
 	l = len(m.Snapshot)
@@ -6838,26 +6723,6 @@ func (m *Clients) Size() (n int) {
 	return n
 }
 
-func (m *DocumentKey) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Collection)
-	if l > 0 {
-		n += 1 + l + sovResources(uint64(l))
-	}
-	l = len(m.Document)
-	if l > 0 {
-		n += 1 + l + sovResources(uint64(l))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
 func (m *Checkpoint) Size() (n int) {
 	if m == nil {
 		return 0
@@ -6934,8 +6799,8 @@ func (m *DocEvent) Size() (n int) {
 		n += 1 + l + sovResources(uint64(l))
 	}
 	if len(m.DocumentKeys) > 0 {
-		for _, e := range m.DocumentKeys {
-			l = e.Size()
+		for _, s := range m.DocumentKeys {
+			l = len(s)
 			n += 1 + l + sovResources(uint64(l))
 		}
 	}
@@ -6984,7 +6849,7 @@ func (m *ChangePack) Unmarshal(dAtA []byte) error {
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field DocumentKey", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowResources
@@ -6994,27 +6859,23 @@ func (m *ChangePack) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthResources
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthResources
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.DocumentKey == nil {
-				m.DocumentKey = &DocumentKey{}
-			}
-			if err := m.DocumentKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.DocumentKey = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
@@ -13117,7 +12978,7 @@ func (m *DocumentSummary) Unmarshal(dAtA []byte) error {
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowResources
@@ -13127,27 +12988,23 @@ func (m *DocumentSummary) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthResources
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthResources
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Key == nil {
-				m.Key = &DocumentKey{}
-			}
-			if err := m.Key.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Key = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
@@ -13606,121 +13463,6 @@ func (m *Clients) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *DocumentKey) 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 ErrIntOverflowResources
-			}
-			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: DocumentKey: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: DocumentKey: 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 ErrIntOverflowResources
-				}
-				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 ErrInvalidLengthResources
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthResources
-			}
-			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 Document", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowResources
-				}
-				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 ErrInvalidLengthResources
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthResources
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Document = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipResources(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthResources
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
 func (m *Checkpoint) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -14146,7 +13888,7 @@ func (m *DocEvent) Unmarshal(dAtA []byte) error {
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field DocumentKeys", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowResources
@@ -14156,25 +13898,23 @@ func (m *DocEvent) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthResources
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthResources
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.DocumentKeys = append(m.DocumentKeys, &DocumentKey{})
-			if err := m.DocumentKeys[len(m.DocumentKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.DocumentKeys = append(m.DocumentKeys, string(dAtA[iNdEx:postIndex]))
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
diff --git a/api/resources.proto b/api/resources.proto
index c86db3f9..1235c325 100644
--- a/api/resources.proto
+++ b/api/resources.proto
@@ -24,7 +24,7 @@ package api;
 /////////////////////////////////////////
 
 message ChangePack {
-  DocumentKey document_key = 1;
+  string document_key = 1;
   Checkpoint checkpoint = 2;
   bytes snapshot = 3;
   repeated Change changes = 4;
@@ -231,7 +231,7 @@ message Project {
 
 message DocumentSummary {
   string id = 1;
-  DocumentKey key = 2;
+  string key = 2;
   string snapshot = 3;
 }
 
@@ -249,11 +249,6 @@ message Clients {
   repeated Client clients = 1;
 }
 
-message DocumentKey {
-  string collection = 1;
-  string document = 2;
-}
-
 message Checkpoint {
   uint64 server_seq = 1 [jstype = JS_STRING];
   uint32 client_seq = 2;
@@ -299,5 +294,5 @@ enum DocEventType {
 message DocEvent {
   DocEventType type = 1;
   Client publisher = 2;
-  repeated DocumentKey document_keys = 3;
+  repeated string document_keys = 3;
 }
diff --git a/api/yorkie.pb.go b/api/yorkie.pb.go
index c8e9faf1..3d73d4c9 100644
--- a/api/yorkie.pb.go
+++ b/api/yorkie.pb.go
@@ -443,11 +443,11 @@ func (m *DetachDocumentResponse) GetChangePack() *ChangePack {
 }
 
 type WatchDocumentsRequest struct {
-	Client               *Client        `protobuf:"bytes,1,opt,name=client,proto3" json:"client,omitempty"`
-	DocumentKeys         []*DocumentKey `protobuf:"bytes,2,rep,name=document_keys,json=documentKeys,proto3" json:"document_keys,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
-	XXX_unrecognized     []byte         `json:"-"`
-	XXX_sizecache        int32          `json:"-"`
+	Client               *Client  `protobuf:"bytes,1,opt,name=client,proto3" json:"client,omitempty"`
+	DocumentKeys         []string `protobuf:"bytes,2,rep,name=document_keys,json=documentKeys,proto3" json:"document_keys,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *WatchDocumentsRequest) Reset()         { *m = WatchDocumentsRequest{} }
@@ -490,7 +490,7 @@ func (m *WatchDocumentsRequest) GetClient() *Client {
 	return nil
 }
 
-func (m *WatchDocumentsRequest) GetDocumentKeys() []*DocumentKey {
+func (m *WatchDocumentsRequest) GetDocumentKeys() []string {
 	if m != nil {
 		return m.DocumentKeys
 	}
@@ -743,11 +743,11 @@ func (m *PushPullResponse) GetChangePack() *ChangePack {
 }
 
 type UpdateMetadataRequest struct {
-	Client               *Client        `protobuf:"bytes,1,opt,name=client,proto3" json:"client,omitempty"`
-	DocumentKeys         []*DocumentKey `protobuf:"bytes,2,rep,name=document_keys,json=documentKeys,proto3" json:"document_keys,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
-	XXX_unrecognized     []byte         `json:"-"`
-	XXX_sizecache        int32          `json:"-"`
+	Client               *Client  `protobuf:"bytes,1,opt,name=client,proto3" json:"client,omitempty"`
+	DocumentKeys         []string `protobuf:"bytes,2,rep,name=document_keys,json=documentKeys,proto3" json:"document_keys,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *UpdateMetadataRequest) Reset()         { *m = UpdateMetadataRequest{} }
@@ -790,7 +790,7 @@ func (m *UpdateMetadataRequest) GetClient() *Client {
 	return nil
 }
 
-func (m *UpdateMetadataRequest) GetDocumentKeys() []*DocumentKey {
+func (m *UpdateMetadataRequest) GetDocumentKeys() []string {
 	if m != nil {
 		return m.DocumentKeys
 	}
@@ -837,11 +837,11 @@ func (m *UpdateMetadataResponse) XXX_DiscardUnknown() {
 var xxx_messageInfo_UpdateMetadataResponse proto.InternalMessageInfo
 
 type ListChangesRequest struct {
-	ClientId             []byte       `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
-	DocumentKey          *DocumentKey `protobuf:"bytes,2,opt,name=document_key,json=documentKey,proto3" json:"document_key,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
+	ClientId             []byte   `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
+	DocumentKey          string   `protobuf:"bytes,2,opt,name=document_key,json=documentKey,proto3" json:"document_key,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *ListChangesRequest) Reset()         { *m = ListChangesRequest{} }
@@ -884,11 +884,11 @@ func (m *ListChangesRequest) GetClientId() []byte {
 	return nil
 }
 
-func (m *ListChangesRequest) GetDocumentKey() *DocumentKey {
+func (m *ListChangesRequest) GetDocumentKey() string {
 	if m != nil {
 		return m.DocumentKey
 	}
-	return nil
+	return ""
 }
 
 type ListChangesResponse struct {
@@ -962,51 +962,51 @@ func init() {
 func init() { proto.RegisterFile("yorkie.proto", fileDescriptor_b60f170c5b305914) }
 
 var fileDescriptor_b60f170c5b305914 = []byte{
-	// 704 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xdd, 0x4e, 0x13, 0x41,
-	0x14, 0xee, 0x16, 0xa8, 0x70, 0xb6, 0x94, 0x66, 0xb4, 0x65, 0xb3, 0x48, 0x43, 0xd6, 0x90, 0x10,
-	0x2f, 0x1a, 0x52, 0x22, 0xfe, 0x44, 0x2f, 0x28, 0x98, 0x40, 0x2a, 0xa6, 0x6e, 0x30, 0xc6, 0xab,
-	0x3a, 0xec, 0x4e, 0x61, 0xd2, 0xd2, 0x5d, 0x3b, 0x53, 0x92, 0xf5, 0x49, 0x7c, 0x24, 0x2e, 0x7d,
-	0x01, 0x13, 0x83, 0x37, 0x3e, 0x86, 0xe9, 0xcc, 0x6c, 0xdb, 0xdd, 0x0e, 0x5a, 0x4d, 0xe0, 0xae,
-	0x7b, 0xce, 0x9c, 0xef, 0x67, 0xce, 0xcc, 0x9c, 0x42, 0x3e, 0x0a, 0xfa, 0x1d, 0x4a, 0xaa, 0x61,
-	0x3f, 0xe0, 0x01, 0x9a, 0xc3, 0x21, 0xb5, 0x57, 0xfa, 0x84, 0x05, 0x83, 0xbe, 0x47, 0x98, 0x8c,
-	0x3a, 0xbb, 0x50, 0xda, 0xf3, 0x38, 0xbd, 0xc4, 0x9c, 0xec, 0x77, 0x29, 0xe9, 0x71, 0x97, 0x7c,
-	0x1e, 0x10, 0xc6, 0xd1, 0x3a, 0x80, 0x27, 0x02, 0xad, 0x0e, 0x89, 0x2c, 0x63, 0xc3, 0xd8, 0x5a,
-	0x72, 0x97, 0x64, 0xa4, 0x41, 0x22, 0xe7, 0x04, 0xca, 0xe9, 0x3a, 0x16, 0x06, 0x3d, 0x46, 0xfe,
-	0x52, 0x88, 0xd6, 0x40, 0x7d, 0xb4, 0xa8, 0x6f, 0x65, 0x37, 0x8c, 0xad, 0xbc, 0xbb, 0x28, 0x03,
-	0x47, 0xbe, 0xb3, 0x0b, 0xab, 0x07, 0x04, 0x6b, 0xf5, 0x24, 0xea, 0x8c, 0x54, 0xdd, 0x53, 0xb0,
-	0xa6, 0xeb, 0x94, 0x9e, 0x3f, 0x16, 0xb6, 0xa1, 0xb4, 0xc7, 0x39, 0xf6, 0xce, 0x0f, 0x02, 0x6f,
-	0x70, 0x31, 0x23, 0x1d, 0xda, 0x06, 0xd3, 0x3b, 0xc7, 0xbd, 0x33, 0xd2, 0x0a, 0xb1, 0xd7, 0x11,
-	0x2e, 0xcc, 0xda, 0x4a, 0x15, 0x87, 0xb4, 0xba, 0x2f, 0xe2, 0x4d, 0xec, 0x75, 0x5c, 0xf0, 0x46,
-	0xbf, 0x9d, 0x33, 0x28, 0xa7, 0x79, 0x66, 0x90, 0xf7, 0x1f, 0x44, 0x6d, 0x28, 0x1d, 0x90, 0x3b,
-	0x30, 0x44, 0xa1, 0x9c, 0xe6, 0x99, 0xad, 0xff, 0xff, 0x4e, 0xc5, 0xa0, 0xf4, 0x01, 0xf3, 0x31,
-	0x13, 0x8b, 0x2d, 0x3d, 0x82, 0x9c, 0xc4, 0x15, 0x2c, 0x66, 0xcd, 0x94, 0x28, 0xb2, 0xfd, 0x2a,
-	0x85, 0x9e, 0xc0, 0xb2, 0xaf, 0x0a, 0x87, 0x82, 0x98, 0x95, 0xdd, 0x98, 0xdb, 0x32, 0x6b, 0x45,
-	0xb1, 0x36, 0x86, 0x6c, 0x90, 0xc8, 0xcd, 0xfb, 0xe3, 0x0f, 0xe6, 0xfc, 0xca, 0x42, 0x39, 0xcd,
-	0xaa, 0x0c, 0x9e, 0x40, 0x81, 0xf6, 0x28, 0xa7, 0xb8, 0x4b, 0xbf, 0x60, 0x4e, 0x83, 0x9e, 0xa2,
-	0x7f, 0x2c, 0x20, 0xf5, 0x45, 0xd5, 0xa3, 0x44, 0xc5, 0x61, 0xc6, 0x4d, 0x61, 0xa0, 0x4d, 0x58,
-	0x20, 0x97, 0x43, 0x2f, 0x72, 0x47, 0x96, 0x63, 0x7d, 0xaf, 0x87, 0xc1, 0xc3, 0x8c, 0x2b, 0xb3,
-	0xf6, 0x95, 0x01, 0x85, 0x24, 0x16, 0x6a, 0x43, 0x31, 0x24, 0xa4, 0xcf, 0x5a, 0x17, 0x38, 0x6c,
-	0x9d, 0x46, 0x2d, 0x3f, 0xf0, 0x2c, 0x43, 0x98, 0x7c, 0x35, 0xbb, 0xa2, 0x6a, 0x73, 0x08, 0x71,
-	0x8c, 0xc3, 0x7a, 0x34, 0x24, 0xed, 0xf1, 0x7e, 0xe4, 0x2e, 0x87, 0x93, 0x31, 0xfb, 0x2d, 0xa0,
-	0xe9, 0x45, 0xa8, 0x08, 0x73, 0xe3, 0x3e, 0x0f, 0x7f, 0x22, 0x07, 0x16, 0x2e, 0x71, 0x77, 0x40,
-	0x94, 0x93, 0xfc, 0x44, 0x57, 0x98, 0x2b, 0x53, 0x2f, 0xb2, 0xcf, 0x8c, 0x7a, 0x0e, 0xe6, 0x4f,
-	0x03, 0x3f, 0x72, 0x3e, 0xc1, 0x4a, 0x73, 0xc0, 0xce, 0x9b, 0x83, 0x6e, 0xf7, 0x96, 0x0e, 0x2b,
-	0x86, 0xe2, 0x98, 0xe1, 0x76, 0xee, 0x1d, 0x83, 0xd2, 0xfb, 0xd0, 0xc7, 0x9c, 0x1c, 0x13, 0x8e,
-	0x7d, 0xcc, 0xf1, 0x5d, 0x1c, 0x52, 0x0b, 0xca, 0x69, 0x52, 0xe9, 0xce, 0x69, 0x03, 0x7a, 0x43,
-	0x19, 0x97, 0x62, 0xd9, 0x4c, 0xdb, 0xba, 0x03, 0xf9, 0x49, 0x0d, 0xca, 0xf4, 0xb4, 0x04, 0x73,
-	0x42, 0x82, 0xf3, 0x12, 0xee, 0x27, 0x78, 0xd4, 0xe6, 0x6e, 0xc2, 0x3d, 0xb9, 0x37, 0x4c, 0x9d,
-	0x44, 0x73, 0x62, 0xef, 0xdc, 0x38, 0x57, 0xfb, 0x3e, 0x0f, 0xb9, 0x8f, 0x62, 0x46, 0xa1, 0x06,
-	0x14, 0x92, 0xf3, 0x04, 0xd9, 0xa2, 0x44, 0x3b, 0x9c, 0xec, 0x35, 0x6d, 0x4e, 0x79, 0xcf, 0xa0,
-	0x77, 0x50, 0x4c, 0x8f, 0x03, 0xf4, 0x50, 0x1a, 0xd1, 0x4f, 0x17, 0x7b, 0xfd, 0x86, 0xec, 0x08,
-	0xb2, 0x01, 0x85, 0xe4, 0x56, 0x2b, 0x7d, 0xda, 0xa6, 0x2b, 0x7d, 0x37, 0xf4, 0x46, 0x80, 0x25,
-	0xa7, 0x41, 0x6c, 0x56, 0x37, 0x8a, 0x62, 0xb3, 0xda, 0xf1, 0x21, 0xc1, 0x92, 0x2f, 0xb1, 0x02,
-	0xd3, 0x8e, 0x01, 0x05, 0xa6, 0x7f, 0xba, 0x9d, 0x0c, 0x3a, 0x86, 0x42, 0xf2, 0xb9, 0x50, 0x60,
-	0xda, 0x07, 0x58, 0x81, 0xe9, 0xdf, 0x17, 0x27, 0xb3, 0x6d, 0xa0, 0xe7, 0xb0, 0x18, 0x5f, 0x3c,
-	0xf4, 0x40, 0x2c, 0x4e, 0xdd, 0x74, 0xbb, 0x94, 0x8a, 0x8e, 0x94, 0xd4, 0xc1, 0x9c, 0x38, 0x59,
-	0x68, 0x55, 0xac, 0x9b, 0x3e, 0xd3, 0xb6, 0x35, 0x9d, 0x88, 0x31, 0xea, 0xc5, 0xab, 0xeb, 0x8a,
-	0xf1, 0xed, 0xba, 0x62, 0xfc, 0xb8, 0xae, 0x18, 0x5f, 0x7f, 0x56, 0x32, 0xa7, 0x39, 0xf1, 0xaf,
-	0x67, 0xe7, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x9c, 0xad, 0x85, 0x1f, 0x1b, 0x09, 0x00, 0x00,
+	// 703 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xcd, 0x6e, 0xd3, 0x40,
+	0x10, 0x8e, 0x93, 0x36, 0x34, 0xe3, 0x34, 0x8d, 0x16, 0x92, 0x5a, 0x2e, 0x8d, 0x82, 0xab, 0x4a,
+	0x11, 0x87, 0xa8, 0x0a, 0x52, 0xf9, 0x11, 0x1c, 0x9a, 0x06, 0xa9, 0x55, 0x28, 0x0a, 0x56, 0x11,
+	0xe2, 0x14, 0xb6, 0xf6, 0xb6, 0x5d, 0x25, 0x8d, 0x4d, 0x76, 0x53, 0xc9, 0x3c, 0x09, 0x8f, 0xd4,
+	0x23, 0x2f, 0x80, 0x84, 0xca, 0x85, 0xc7, 0x40, 0xd9, 0x5d, 0xb7, 0xb6, 0xe3, 0x42, 0x40, 0x94,
+	0x9b, 0x33, 0xb3, 0xf3, 0x7d, 0xf3, 0xed, 0xcc, 0xce, 0x04, 0x8a, 0x81, 0x37, 0x1e, 0x50, 0xd2,
+	0xf4, 0xc7, 0x1e, 0xf7, 0x50, 0x0e, 0xfb, 0xd4, 0x5c, 0x19, 0x13, 0xe6, 0x4d, 0xc6, 0x0e, 0x61,
+	0xd2, 0x6a, 0x6d, 0x43, 0x65, 0xc7, 0xe1, 0xf4, 0x1c, 0x73, 0xb2, 0x3b, 0xa4, 0x64, 0xc4, 0x6d,
+	0xf2, 0x71, 0x42, 0x18, 0x47, 0xeb, 0x00, 0x8e, 0x30, 0xf4, 0x07, 0x24, 0x30, 0xb4, 0xba, 0xd6,
+	0x28, 0xd8, 0x05, 0x69, 0xe9, 0x92, 0xc0, 0x3a, 0x84, 0x6a, 0x32, 0x8e, 0xf9, 0xde, 0x88, 0x91,
+	0xdf, 0x04, 0xa2, 0x35, 0x50, 0x3f, 0xfa, 0xd4, 0x35, 0xb2, 0x75, 0xad, 0x51, 0xb4, 0x97, 0xa4,
+	0x61, 0xdf, 0xb5, 0xb6, 0x61, 0xb5, 0x43, 0x70, 0x6a, 0x3e, 0xb1, 0x38, 0x2d, 0x11, 0xf7, 0x18,
+	0x8c, 0xd9, 0x38, 0x95, 0xcf, 0x2f, 0x03, 0x8f, 0xa1, 0xb2, 0xc3, 0x39, 0x76, 0x4e, 0x3b, 0x9e,
+	0x33, 0x39, 0x9b, 0x93, 0x0e, 0x6d, 0x81, 0xee, 0x9c, 0xe2, 0xd1, 0x09, 0xe9, 0xfb, 0xd8, 0x19,
+	0x08, 0x15, 0x7a, 0x6b, 0xa5, 0x89, 0x7d, 0xda, 0xdc, 0x15, 0xf6, 0x1e, 0x76, 0x06, 0x36, 0x38,
+	0x57, 0xdf, 0xd6, 0x09, 0x54, 0x93, 0x3c, 0x73, 0xa4, 0xf7, 0x17, 0x44, 0xc7, 0x50, 0xe9, 0x90,
+	0xff, 0x20, 0x88, 0x42, 0x35, 0xc9, 0x33, 0x5f, 0xfd, 0xff, 0x9c, 0x0a, 0x43, 0xe5, 0x1d, 0xe6,
+	0xd7, 0x4c, 0x2c, 0x94, 0xb4, 0x01, 0x79, 0x89, 0x2b, 0x58, 0xf4, 0x96, 0x2e, 0x51, 0x64, 0xf9,
+	0x95, 0x0b, 0x6d, 0xc0, 0xb2, 0xab, 0x02, 0xa7, 0x09, 0x31, 0x23, 0x5b, 0xcf, 0x35, 0x0a, 0x76,
+	0x31, 0x34, 0x76, 0x49, 0xc0, 0xac, 0x1f, 0x59, 0xa8, 0x26, 0x39, 0x94, 0x9c, 0x43, 0x28, 0xd1,
+	0x11, 0xe5, 0x14, 0x0f, 0xe9, 0x27, 0xcc, 0xa9, 0x37, 0x52, 0x64, 0x0f, 0x05, 0x59, 0x7a, 0x50,
+	0x73, 0x3f, 0x16, 0xb1, 0x97, 0xb1, 0x13, 0x18, 0x68, 0x13, 0x16, 0xc9, 0xf9, 0x34, 0x73, 0xa9,
+	0x7f, 0x59, 0x80, 0x75, 0x3c, 0xe7, 0xe5, 0xd4, 0xb8, 0x97, 0xb1, 0xa5, 0xd7, 0xbc, 0xd0, 0xa0,
+	0x14, 0xc7, 0x42, 0xc7, 0x50, 0xf6, 0x09, 0x19, 0xb3, 0xfe, 0x19, 0xf6, 0xfb, 0x47, 0x41, 0xdf,
+	0xf5, 0x1c, 0x43, 0xab, 0xe7, 0x1a, 0x7a, 0xeb, 0xc5, 0xfc, 0x19, 0x35, 0x7b, 0x53, 0x88, 0x03,
+	0xec, 0xb7, 0x83, 0x29, 0xe9, 0x88, 0x8f, 0x03, 0x7b, 0xd9, 0x8f, 0xda, 0xcc, 0xd7, 0x80, 0x66,
+	0x0f, 0xa1, 0x32, 0xe4, 0xae, 0xab, 0x3a, 0xfd, 0x44, 0x16, 0x2c, 0x9e, 0xe3, 0xe1, 0x84, 0x28,
+	0x25, 0xc5, 0x48, 0x0d, 0x98, 0x2d, 0x5d, 0xcf, 0xb2, 0x4f, 0xb4, 0x76, 0x1e, 0x16, 0x8e, 0x3c,
+	0x37, 0xb0, 0x3e, 0xc0, 0x4a, 0x6f, 0xc2, 0x4e, 0x7b, 0x93, 0xe1, 0xf0, 0x96, 0x5a, 0x13, 0x43,
+	0xf9, 0x9a, 0xe1, 0x76, 0x5e, 0x19, 0x86, 0xca, 0x5b, 0xdf, 0xc5, 0x9c, 0x1c, 0x10, 0x8e, 0x5d,
+	0xcc, 0xf1, 0xbf, 0x6f, 0x49, 0x03, 0xaa, 0x49, 0x0a, 0xa9, 0xc5, 0x3a, 0x04, 0xf4, 0x8a, 0x32,
+	0x2e, 0x53, 0x63, 0x73, 0x5d, 0xe2, 0x03, 0x28, 0x46, 0x19, 0x85, 0xc4, 0x82, 0xad, 0x47, 0x08,
+	0xad, 0xe7, 0x70, 0x37, 0x86, 0xaa, 0x2e, 0x6e, 0x13, 0xee, 0x48, 0xdd, 0x4c, 0x75, 0x99, 0x1e,
+	0xb9, 0x17, 0x3b, 0xf4, 0xb5, 0xbe, 0x2e, 0x40, 0xfe, 0xbd, 0xd8, 0x36, 0xa8, 0x0b, 0xa5, 0xf8,
+	0x66, 0x40, 0xa6, 0x08, 0x49, 0x5d, 0x33, 0xe6, 0x5a, 0xaa, 0x4f, 0x29, 0xcd, 0xa0, 0x37, 0x50,
+	0x4e, 0x0e, 0x76, 0x74, 0x5f, 0x3e, 0x96, 0xf4, 0x3d, 0x61, 0xae, 0xdf, 0xe0, 0xbd, 0x82, 0xec,
+	0x42, 0x29, 0x7e, 0xb1, 0x2a, 0xbf, 0xd4, 0x82, 0xaa, 0xfc, 0x6e, 0xa8, 0x84, 0x00, 0x8b, 0xcf,
+	0xf5, 0x50, 0x6c, 0xda, 0x52, 0x09, 0xc5, 0xa6, 0x2e, 0x02, 0x09, 0x16, 0x9f, 0xa9, 0x0a, 0x2c,
+	0x75, 0xa0, 0x2b, 0xb0, 0xf4, 0x21, 0x6c, 0x65, 0xd0, 0x01, 0x94, 0xe2, 0xa3, 0x40, 0x81, 0xa5,
+	0x8e, 0x52, 0x05, 0x96, 0x3e, 0x3b, 0xac, 0xcc, 0x96, 0x86, 0x9e, 0xc2, 0x52, 0xf8, 0xa8, 0xd0,
+	0x3d, 0x71, 0x38, 0xf1, 0x8a, 0xcd, 0x4a, 0xc2, 0x7a, 0x95, 0x49, 0x1b, 0xf4, 0x48, 0x67, 0xa1,
+	0x55, 0x71, 0x6e, 0xb6, 0x83, 0x4d, 0x63, 0xd6, 0x11, 0x62, 0xb4, 0xcb, 0x17, 0x97, 0x35, 0xed,
+	0xcb, 0x65, 0x4d, 0xfb, 0x76, 0x59, 0xd3, 0x3e, 0x7f, 0xaf, 0x65, 0x8e, 0xf2, 0xe2, 0xff, 0xcb,
+	0xa3, 0x9f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd5, 0x3b, 0x87, 0x39, 0xe5, 0x08, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1722,14 +1722,9 @@ func (m *WatchDocumentsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	}
 	if len(m.DocumentKeys) > 0 {
 		for iNdEx := len(m.DocumentKeys) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.DocumentKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintYorkie(dAtA, i, uint64(size))
-			}
+			i -= len(m.DocumentKeys[iNdEx])
+			copy(dAtA[i:], m.DocumentKeys[iNdEx])
+			i = encodeVarintYorkie(dAtA, i, uint64(len(m.DocumentKeys[iNdEx])))
 			i--
 			dAtA[i] = 0x12
 		}
@@ -1998,14 +1993,9 @@ func (m *UpdateMetadataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	}
 	if len(m.DocumentKeys) > 0 {
 		for iNdEx := len(m.DocumentKeys) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.DocumentKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintYorkie(dAtA, i, uint64(size))
-			}
+			i -= len(m.DocumentKeys[iNdEx])
+			copy(dAtA[i:], m.DocumentKeys[iNdEx])
+			i = encodeVarintYorkie(dAtA, i, uint64(len(m.DocumentKeys[iNdEx])))
 			i--
 			dAtA[i] = 0x12
 		}
@@ -2076,15 +2066,10 @@ func (m *ListChangesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	if m.DocumentKey != nil {
-		{
-			size, err := m.DocumentKey.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintYorkie(dAtA, i, uint64(size))
-		}
+	if len(m.DocumentKey) > 0 {
+		i -= len(m.DocumentKey)
+		copy(dAtA[i:], m.DocumentKey)
+		i = encodeVarintYorkie(dAtA, i, uint64(len(m.DocumentKey)))
 		i--
 		dAtA[i] = 0x12
 	}
@@ -2309,8 +2294,8 @@ func (m *WatchDocumentsRequest) Size() (n int) {
 		n += 1 + l + sovYorkie(uint64(l))
 	}
 	if len(m.DocumentKeys) > 0 {
-		for _, e := range m.DocumentKeys {
-			l = e.Size()
+		for _, s := range m.DocumentKeys {
+			l = len(s)
 			n += 1 + l + sovYorkie(uint64(l))
 		}
 	}
@@ -2435,8 +2420,8 @@ func (m *UpdateMetadataRequest) Size() (n int) {
 		n += 1 + l + sovYorkie(uint64(l))
 	}
 	if len(m.DocumentKeys) > 0 {
-		for _, e := range m.DocumentKeys {
-			l = e.Size()
+		for _, s := range m.DocumentKeys {
+			l = len(s)
 			n += 1 + l + sovYorkie(uint64(l))
 		}
 	}
@@ -2468,8 +2453,8 @@ func (m *ListChangesRequest) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovYorkie(uint64(l))
 	}
-	if m.DocumentKey != nil {
-		l = m.DocumentKey.Size()
+	l = len(m.DocumentKey)
+	if l > 0 {
 		n += 1 + l + sovYorkie(uint64(l))
 	}
 	if m.XXX_unrecognized != nil {
@@ -3423,7 +3408,7 @@ func (m *WatchDocumentsRequest) Unmarshal(dAtA []byte) error {
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field DocumentKeys", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowYorkie
@@ -3433,25 +3418,23 @@ func (m *WatchDocumentsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthYorkie
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthYorkie
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.DocumentKeys = append(m.DocumentKeys, &DocumentKey{})
-			if err := m.DocumentKeys[len(m.DocumentKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.DocumentKeys = append(m.DocumentKeys, string(dAtA[iNdEx:postIndex]))
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -4087,7 +4070,7 @@ func (m *UpdateMetadataRequest) Unmarshal(dAtA []byte) error {
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field DocumentKeys", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowYorkie
@@ -4097,25 +4080,23 @@ func (m *UpdateMetadataRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthYorkie
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthYorkie
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.DocumentKeys = append(m.DocumentKeys, &DocumentKey{})
-			if err := m.DocumentKeys[len(m.DocumentKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.DocumentKeys = append(m.DocumentKeys, string(dAtA[iNdEx:postIndex]))
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -4257,7 +4238,7 @@ func (m *ListChangesRequest) Unmarshal(dAtA []byte) error {
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field DocumentKey", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowYorkie
@@ -4267,27 +4248,23 @@ func (m *ListChangesRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthYorkie
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthYorkie
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.DocumentKey == nil {
-				m.DocumentKey = &DocumentKey{}
-			}
-			if err := m.DocumentKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.DocumentKey = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
diff --git a/api/yorkie.proto b/api/yorkie.proto
index 0fbde5f2..a68cad44 100644
--- a/api/yorkie.proto
+++ b/api/yorkie.proto
@@ -73,7 +73,7 @@ message DetachDocumentResponse {
 
 message WatchDocumentsRequest {
   Client client = 1;
-  repeated DocumentKey document_keys = 2;
+  repeated string document_keys = 2;
 }
 
 message WatchDocumentsResponse {
@@ -99,14 +99,14 @@ message PushPullResponse {
 
 message UpdateMetadataRequest {
   Client client = 1;
-  repeated DocumentKey document_keys = 2;
+  repeated string document_keys = 2;
 }
 
 message UpdateMetadataResponse {}
 
 message ListChangesRequest {
   bytes client_id = 1;
-  DocumentKey document_key = 2;
+  string document_key = 2;
 }
 
 message ListChangesResponse {
diff --git a/client/client.go b/client/client.go
index 3d46c971..a5a2e3e0 100644
--- a/client/client.go
+++ b/client/client.go
@@ -268,7 +268,7 @@ func (c *Client) Attach(ctx context.Context, doc *document.Document) error {
 	}
 
 	doc.SetStatus(document.Attached)
-	c.attachments[doc.Key().CombinedKey()] = &Attachment{
+	c.attachments[doc.Key().String()] = &Attachment{
 		doc:   doc,
 		peers: make(map[string]types.MetadataInfo),
 	}
@@ -287,7 +287,7 @@ func (c *Client) Detach(ctx context.Context, doc *document.Document) error {
 		return ErrClientNotActivated
 	}
 
-	if _, ok := c.attachments[doc.Key().CombinedKey()]; !ok {
+	if _, ok := c.attachments[doc.Key().String()]; !ok {
 		return ErrDocumentNotAttached
 	}
 
@@ -314,7 +314,7 @@ func (c *Client) Detach(ctx context.Context, doc *document.Document) error {
 	}
 
 	doc.SetStatus(document.Detached)
-	delete(c.attachments, doc.Key().CombinedKey())
+	delete(c.attachments, doc.Key().String())
 
 	return nil
 }
@@ -399,7 +399,7 @@ func (c *Client) Watch(
 						return nil, err
 					}
 
-					attachment := c.attachments[k.CombinedKey()]
+					attachment := c.attachments[k.String()]
 					if eventType == types.DocumentsWatchedEvent ||
 						eventType == types.MetadataChangedEvent {
 						if info, ok := attachment.peers[cli.ID.String()]; ok {
@@ -487,7 +487,7 @@ func (c *Client) UpdateMetadata(ctx context.Context, k, v string) error {
 func (c *Client) ListChangeSummaries(ctx context.Context, key key.Key) ([]*types.ChangeSummary, error) {
 	resp, err := c.client.ListChanges(ctx, &api.ListChangesRequest{
 		ClientId:    c.id.Bytes(),
-		DocumentKey: converter.ToDocumentKey(key),
+		DocumentKey: key.String(),
 	})
 	if err != nil {
 		return nil, err
@@ -560,7 +560,7 @@ func (c *Client) sync(ctx context.Context, key key.Key) error {
 		return ErrClientNotActivated
 	}
 
-	attachment, ok := c.attachments[key.CombinedKey()]
+	attachment, ok := c.attachments[key.String()]
 	if !ok {
 		return ErrDocumentNotAttached
 	}
diff --git a/pkg/document/document.go b/pkg/document/document.go
index d47579f0..a6d54fd8 100644
--- a/pkg/document/document.go
+++ b/pkg/document/document.go
@@ -43,10 +43,9 @@ type Document struct {
 }
 
 // New creates a new instance of Document.
-func New(collection, document string) *Document {
-	k := key.Key{Collection: collection, Document: document}
+func New(key key.Key) *Document {
 	return &Document{
-		doc: NewInternalDocument(k),
+		doc: NewInternalDocument(key),
 	}
 }
 
diff --git a/pkg/document/key/key.go b/pkg/document/key/key.go
index 9e6f8221..76820189 100644
--- a/pkg/document/key/key.go
+++ b/pkg/document/key/key.go
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 The Yorkie Authors. All rights reserved.
+ * Copyright 2022 The Yorkie Authors. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,38 +16,10 @@
 
 package key
 
-import (
-	"errors"
-	"fmt"
-	"strings"
-)
+// Key represents a document key.
+type Key string
 
-const (
-	// Splitter is used to separate collection and document in a string.
-	Splitter = "$"
-	tokenLen = 2
-)
-
-// ErrInvalidCombinedKey is returned when the given combined key is invalid.
-var ErrInvalidCombinedKey = errors.New("invalid combined key")
-
-// Key represents the key of the Document.
-type Key struct {
-	Collection string
-	Document   string
-}
-
-// FromCombinedKey creates an instance of Key from the given combined key.
-func FromCombinedKey(k string) (Key, error) {
-	splits := strings.Split(k, Splitter)
-	if len(splits) != tokenLen {
-		return Key{}, fmt.Errorf("%s: %w", k, ErrInvalidCombinedKey)
-	}
-
-	return Key{Collection: splits[0], Document: splits[1]}, nil
-}
-
-// CombinedKey returns the string of this key.
-func (k Key) CombinedKey() string {
-	return k.Collection + Splitter + k.Document
+// String returns the string representation of the key.
+func (k Key) String() string {
+	return string(k)
 }
diff --git a/server/backend/db/db.go b/server/backend/db/db.go
index a95c4110..17e08215 100644
--- a/server/backend/db/db.go
+++ b/server/backend/db/db.go
@@ -24,6 +24,7 @@ import (
 	"github.com/yorkie-team/yorkie/api/types"
 	"github.com/yorkie-team/yorkie/pkg/document"
 	"github.com/yorkie-team/yorkie/pkg/document/change"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 	"github.com/yorkie-team/yorkie/pkg/document/time"
 )
 
@@ -87,7 +88,7 @@ type DB interface {
 	FindDocInfoByKey(
 		ctx context.Context,
 		clientInfo *ClientInfo,
-		bsonDocKey string,
+		docKey key.Key,
 		createDocIfNotExist bool,
 	) (*DocInfo, error)
 
diff --git a/server/backend/db/doc_info.go b/server/backend/db/doc_info.go
index 8d3f86a8..d55e11a7 100644
--- a/server/backend/db/doc_info.go
+++ b/server/backend/db/doc_info.go
@@ -25,13 +25,13 @@ import (
 
 // DocInfo is a structure representing information of the document.
 type DocInfo struct {
-	ID          types.ID  `bson:"_id"`
-	CombinedKey string    `bson:"key"`
-	ServerSeq   uint64    `bson:"server_seq"`
-	Owner       types.ID  `bson:"owner"`
-	CreatedAt   time.Time `bson:"created_at"`
-	AccessedAt  time.Time `bson:"accessed_at"`
-	UpdatedAt   time.Time `bson:"updated_at"`
+	ID         types.ID  `bson:"_id"`
+	Key        key.Key   `bson:"key"`
+	ServerSeq  uint64    `bson:"server_seq"`
+	Owner      types.ID  `bson:"owner"`
+	CreatedAt  time.Time `bson:"created_at"`
+	AccessedAt time.Time `bson:"accessed_at"`
+	UpdatedAt  time.Time `bson:"updated_at"`
 }
 
 // IncreaseServerSeq increases server sequence of the document.
@@ -40,16 +40,6 @@ func (info *DocInfo) IncreaseServerSeq() uint64 {
 	return info.ServerSeq
 }
 
-// Key creates Key instance of this DocInfo.
-func (info *DocInfo) Key() (key.Key, error) {
-	docKey, err := key.FromCombinedKey(info.CombinedKey)
-	if err != nil {
-		return key.Key{}, err
-	}
-
-	return docKey, nil
-}
-
 // DeepCopy creates a deep copy of this DocInfo.
 func (info *DocInfo) DeepCopy() *DocInfo {
 	if info == nil {
@@ -57,12 +47,12 @@ func (info *DocInfo) DeepCopy() *DocInfo {
 	}
 
 	return &DocInfo{
-		ID:          info.ID,
-		CombinedKey: info.CombinedKey,
-		ServerSeq:   info.ServerSeq,
-		Owner:       info.Owner,
-		CreatedAt:   info.CreatedAt,
-		AccessedAt:  info.AccessedAt,
-		UpdatedAt:   info.UpdatedAt,
+		ID:         info.ID,
+		Key:        info.Key,
+		ServerSeq:  info.ServerSeq,
+		Owner:      info.Owner,
+		CreatedAt:  info.CreatedAt,
+		AccessedAt: info.AccessedAt,
+		UpdatedAt:  info.UpdatedAt,
 	}
 }
diff --git a/server/backend/db/memory/db.go b/server/backend/db/memory/db.go
index 79ee4d11..f4f44c14 100644
--- a/server/backend/db/memory/db.go
+++ b/server/backend/db/memory/db.go
@@ -28,6 +28,7 @@ import (
 	"github.com/yorkie-team/yorkie/api/types"
 	"github.com/yorkie-team/yorkie/pkg/document"
 	"github.com/yorkie-team/yorkie/pkg/document/change"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 	"github.com/yorkie-team/yorkie/pkg/document/time"
 	"github.com/yorkie-team/yorkie/server/backend/db"
 )
@@ -333,30 +334,30 @@ func (d *DB) FindDeactivateCandidates(
 func (d *DB) FindDocInfoByKey(
 	ctx context.Context,
 	clientInfo *db.ClientInfo,
-	bsonDocKey string,
+	key key.Key,
 	createDocIfNotExist bool,
 ) (*db.DocInfo, error) {
 	txn := d.db.Txn(true)
 	defer txn.Abort()
 
-	raw, err := txn.First(tblDocuments, "key", bsonDocKey)
+	raw, err := txn.First(tblDocuments, "key", key.String())
 	if err != nil {
 		return nil, err
 	}
 	if !createDocIfNotExist && raw == nil {
-		return nil, fmt.Errorf("%s: %w", bsonDocKey, db.ErrDocumentNotFound)
+		return nil, fmt.Errorf("%s: %w", key, db.ErrDocumentNotFound)
 	}
 
 	now := gotime.Now()
 	var docInfo *db.DocInfo
 	if raw == nil {
 		docInfo = &db.DocInfo{
-			ID:          newID(),
-			CombinedKey: bsonDocKey,
-			Owner:       clientInfo.ID,
-			ServerSeq:   0,
-			CreatedAt:   now,
-			AccessedAt:  now,
+			ID:         newID(),
+			Key:        key,
+			Owner:      clientInfo.ID,
+			ServerSeq:  0,
+			CreatedAt:  now,
+			AccessedAt: now,
 		}
 		if err := txn.Insert(tblDocuments, docInfo); err != nil {
 			return nil, err
@@ -399,12 +400,12 @@ func (d *DB) CreateChangeInfos(
 		}
 	}
 
-	raw, err := txn.First(tblDocuments, "key", docInfo.CombinedKey)
+	raw, err := txn.First(tblDocuments, "key", docInfo.Key.String())
 	if err != nil {
 		return err
 	}
 	if raw == nil {
-		return fmt.Errorf("%s: %w", docInfo.CombinedKey, db.ErrDocumentNotFound)
+		return fmt.Errorf("%s: %w", docInfo.Key, db.ErrDocumentNotFound)
 	}
 	loadedDocInfo := raw.(*db.DocInfo).DeepCopy()
 	if loadedDocInfo.ServerSeq != initialServerSeq {
diff --git a/server/backend/db/memory/indexes.go b/server/backend/db/memory/indexes.go
index cd096404..dfcc6b5f 100644
--- a/server/backend/db/memory/indexes.go
+++ b/server/backend/db/memory/indexes.go
@@ -84,7 +84,7 @@ var schema = &memdb.DBSchema{
 				"key": {
 					Name:    "key",
 					Unique:  true,
-					Indexer: &memdb.StringFieldIndex{Field: "CombinedKey"},
+					Indexer: &memdb.StringFieldIndex{Field: "Key"},
 				},
 			},
 		},
diff --git a/server/backend/db/mongo/client.go b/server/backend/db/mongo/client.go
index 4a2f23da..40207c49 100644
--- a/server/backend/db/mongo/client.go
+++ b/server/backend/db/mongo/client.go
@@ -31,6 +31,7 @@ import (
 	"github.com/yorkie-team/yorkie/api/types"
 	"github.com/yorkie-team/yorkie/pkg/document"
 	"github.com/yorkie-team/yorkie/pkg/document/change"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 	"github.com/yorkie-team/yorkie/pkg/document/time"
 	"github.com/yorkie-team/yorkie/server/backend/db"
 	"github.com/yorkie-team/yorkie/server/logging"
@@ -377,7 +378,7 @@ func (c *Client) FindDeactivateCandidates(
 func (c *Client) FindDocInfoByKey(
 	ctx context.Context,
 	clientInfo *db.ClientInfo,
-	bsonDocKey string,
+	docKey key.Key,
 	createDocIfNotExist bool,
 ) (*db.DocInfo, error) {
 	encodedOwnerID, err := encodeID(clientInfo.ID)
@@ -387,7 +388,7 @@ func (c *Client) FindDocInfoByKey(
 
 	now := gotime.Now()
 	res, err := c.collection(colDocuments).UpdateOne(ctx, bson.M{
-		"key": bsonDocKey,
+		"key": docKey,
 	}, bson.M{
 		"$set": bson.M{
 			"accessed_at": now,
@@ -411,11 +412,11 @@ func (c *Client) FindDocInfoByKey(
 		})
 	} else {
 		result = c.collection(colDocuments).FindOne(ctx, bson.M{
-			"key": bsonDocKey,
+			"key": docKey,
 		})
 		if result.Err() == mongo.ErrNoDocuments {
 			logging.From(ctx).Error(result.Err())
-			return nil, fmt.Errorf("%s: %w", bsonDocKey, db.ErrDocumentNotFound)
+			return nil, fmt.Errorf("%s: %w", docKey, db.ErrDocumentNotFound)
 		}
 		if result.Err() != nil {
 			logging.From(ctx).Error(result.Err())
diff --git a/server/backend/sync/etcd/pubsub.go b/server/backend/sync/etcd/pubsub.go
index bd6c7d48..3f1a7c02 100644
--- a/server/backend/sync/etcd/pubsub.go
+++ b/server/backend/sync/etcd/pubsub.go
@@ -63,7 +63,7 @@ func (c *Client) Subscribe(
 			return nil, nil, err
 		}
 
-		peersMap[k.CombinedKey()] = subs
+		peersMap[k.String()] = subs
 	}
 
 	return sub, peersMap, nil
@@ -218,7 +218,7 @@ func (c *Client) putSubscriptions(
 	}
 
 	for _, k := range keys {
-		k := path.Join(subscriptionsPath, k.CombinedKey(), sub.ID())
+		k := path.Join(subscriptionsPath, k.String(), sub.ID())
 		if _, err = c.client.Put(ctx, k, encoded); err != nil {
 			logging.From(ctx).Error(err)
 			return fmt.Errorf("put %s: %w", k, err)
@@ -235,7 +235,7 @@ func (c *Client) pullSubscriptions(
 ) ([]types.Client, error) {
 	getResponse, err := c.client.Get(
 		ctx,
-		path.Join(subscriptionsPath, k.CombinedKey()),
+		path.Join(subscriptionsPath, k.String()),
 		clientv3.WithPrefix(),
 	)
 	if err != nil {
@@ -262,7 +262,7 @@ func (c *Client) removeSubscriptions(
 	sub *sync.Subscription,
 ) error {
 	for _, docKey := range keys {
-		k := path.Join(subscriptionsPath, docKey.CombinedKey(), sub.ID())
+		k := path.Join(subscriptionsPath, docKey.String(), sub.ID())
 		if _, err := c.client.Delete(ctx, k); err != nil {
 			logging.From(ctx).Error(err)
 			return err
diff --git a/server/backend/sync/memory/pubsub.go b/server/backend/sync/memory/pubsub.go
index e5145465..2108bd82 100644
--- a/server/backend/sync/memory/pubsub.go
+++ b/server/backend/sync/memory/pubsub.go
@@ -93,7 +93,7 @@ func (m *PubSub) Subscribe(
 	if logging.Enabled(zap.DebugLevel) {
 		logging.From(ctx).Debugf(
 			`Subscribe(%s,%s) Start`,
-			keys[0].CombinedKey(),
+			keys[0],
 			subscriber.ID.String(),
 		)
 	}
@@ -105,17 +105,17 @@ func (m *PubSub) Subscribe(
 	m.subscriptionMapBySubscriber[sub.SubscriberID()] = sub
 
 	for _, docKey := range keys {
-		combinedKey := docKey.CombinedKey()
-		if _, ok := m.subscriptionsMapByDocKey[combinedKey]; !ok {
-			m.subscriptionsMapByDocKey[combinedKey] = newSubscriptions()
+		key := docKey.String()
+		if _, ok := m.subscriptionsMapByDocKey[key]; !ok {
+			m.subscriptionsMapByDocKey[key] = newSubscriptions()
 		}
-		m.subscriptionsMapByDocKey[combinedKey].Add(sub)
+		m.subscriptionsMapByDocKey[key].Add(sub)
 	}
 
 	if logging.Enabled(zap.DebugLevel) {
 		logging.From(ctx).Debugf(
 			`Subscribe(%s,%s) End`,
-			keys[0].CombinedKey(),
+			keys[0],
 			subscriber.ID.String(),
 		)
 	}
@@ -126,7 +126,7 @@ func (m *PubSub) Subscribe(
 func (m *PubSub) BuildPeersMap(keys []key.Key) map[string][]types.Client {
 	peersMap := make(map[string][]types.Client)
 	for _, docKey := range keys {
-		combinedKey := docKey.CombinedKey()
+		combinedKey := docKey.String()
 		var peers []types.Client
 		for _, sub := range m.subscriptionsMapByDocKey[combinedKey].Map() {
 			peers = append(peers, sub.Subscriber())
@@ -148,7 +148,7 @@ func (m *PubSub) Unsubscribe(
 	if logging.Enabled(zap.DebugLevel) {
 		logging.From(ctx).Debugf(
 			`Unsubscribe(%s,%s) Start`,
-			docKeys[0].CombinedKey(),
+			docKeys[0].String(),
 			sub.SubscriberID(),
 		)
 	}
@@ -157,7 +157,7 @@ func (m *PubSub) Unsubscribe(
 
 	delete(m.subscriptionMapBySubscriber, sub.SubscriberID())
 	for _, docKey := range docKeys {
-		k := docKey.CombinedKey()
+		k := docKey.String()
 		if subs, ok := m.subscriptionsMapByDocKey[k]; ok {
 			subs.Delete(sub.ID())
 
@@ -170,7 +170,7 @@ func (m *PubSub) Unsubscribe(
 	if logging.Enabled(zap.DebugLevel) {
 		logging.From(ctx).Debugf(
 			`Unsubscribe(%s,%s) End`,
-			docKeys[0].CombinedKey(),
+			docKeys[0].String(),
 			sub.SubscriberID(),
 		)
 	}
@@ -186,7 +186,7 @@ func (m *PubSub) Publish(
 	defer m.subscriptionsMapMu.RUnlock()
 
 	for _, docKey := range event.DocumentKeys {
-		k := docKey.CombinedKey()
+		k := docKey.String()
 
 		if logging.Enabled(zap.DebugLevel) {
 			logging.From(ctx).Debugf(`Publish(%s,%s) Start`, k, publisherID.String())
diff --git a/server/clients/clients.go b/server/clients/clients.go
index 8bc73e19..01ac22fe 100644
--- a/server/clients/clients.go
+++ b/server/clients/clients.go
@@ -81,7 +81,7 @@ func FindClientAndDocument(
 	docInfo, err := be.DB.FindDocInfoByKey(
 		ctx,
 		clientInfo,
-		docKey.CombinedKey(),
+		docKey,
 		createDocIfNotExist,
 	)
 	if err != nil {
diff --git a/server/packs/packs.go b/server/packs/packs.go
index 8f0a37f2..b528dede 100644
--- a/server/packs/packs.go
+++ b/server/packs/packs.go
@@ -35,12 +35,12 @@ import (
 
 // PushPullKey creates a new sync.Key of PushPull for the given document.
 func PushPullKey(docKey key.Key) sync.Key {
-	return sync.NewKey(fmt.Sprintf("pushpull-%s", docKey.CombinedKey()))
+	return sync.NewKey(fmt.Sprintf("pushpull-%s", docKey))
 }
 
 // SnapshotKey creates a new sync.Key of Snapshot for the given document.
 func SnapshotKey(docKey key.Key) sync.Key {
-	return sync.NewKey(fmt.Sprintf("snapshot-%s", docKey.CombinedKey()))
+	return sync.NewKey(fmt.Sprintf("snapshot-%s", docKey))
 }
 
 // PushPull stores the given changes and returns accumulated changes of the
@@ -171,13 +171,8 @@ func BuildDocumentForServerSeq(
 		return nil, err
 	}
 
-	docKey, err := docInfo.Key()
-	if err != nil {
-		return nil, err
-	}
-
 	doc, err := document.NewInternalDocumentFromSnapshot(
-		docKey,
+		docInfo.Key,
 		snapshotInfo.ServerSeq,
 		snapshotInfo.Lamport,
 		snapshotInfo.Snapshot,
@@ -200,7 +195,7 @@ func BuildDocumentForServerSeq(
 	}
 
 	if err := doc.ApplyChangePack(change.NewPack(
-		docKey,
+		docInfo.Key,
 		change.InitialCheckpoint.NextServerSeq(serverSeq),
 		changes,
 		nil,
diff --git a/server/packs/pushpull.go b/server/packs/pushpull.go
index a83a8e55..16e65995 100644
--- a/server/packs/pushpull.go
+++ b/server/packs/pushpull.go
@@ -67,7 +67,7 @@ func pushChanges(
 			"PUSH: '%s' pushes %d changes into '%s', rejected %d changes, serverSeq: %d -> %d, cp: %s",
 			clientInfo.ID,
 			len(pushedChanges),
-			docInfo.CombinedKey,
+			docInfo.Key,
 			len(reqPack.Changes)-len(pushedChanges),
 			initialServerSeq,
 			docInfo.ServerSeq,
@@ -87,11 +87,6 @@ func pullPack(
 	cpAfterPush change.Checkpoint,
 	initialServerSeq uint64,
 ) (*ServerPack, error) {
-	docKey, err := docInfo.Key()
-	if err != nil {
-		return nil, err
-	}
-
 	if initialServerSeq < reqPack.Checkpoint.ServerSeq {
 		return nil, fmt.Errorf(
 			"serverSeq of CP greater than serverSeq of clientInfo(clientInfo %d, cp %d): %w",
@@ -115,7 +110,7 @@ func pullPack(
 		if err != nil {
 			return nil, err
 		}
-		return NewServerPack(docKey, cpAfterPull, pulledChanges, nil), err
+		return NewServerPack(docInfo.Key, cpAfterPull, pulledChanges, nil), err
 	}
 
 	return pullSnapshot(ctx, be, clientInfo, docInfo, reqPack, cpAfterPush, initialServerSeq)
@@ -131,11 +126,6 @@ func pullSnapshot(
 	cpAfterPush change.Checkpoint,
 	initialServerSeq uint64,
 ) (*ServerPack, error) {
-	docKey, err := docInfo.Key()
-	if err != nil {
-		return nil, err
-	}
-
 	// Build document from DB if the size of changes for the response is greater than the snapshot threshold.
 	doc, err := BuildDocumentForServerSeq(ctx, be, docInfo, initialServerSeq)
 	if err != nil {
@@ -145,7 +135,7 @@ func pullSnapshot(
 	// Apply changes that are in the request pack.
 	if reqPack.HasChanges() {
 		if err := doc.ApplyChangePack(change.NewPack(
-			docKey,
+			docInfo.Key,
 			doc.Checkpoint().NextServerSeq(docInfo.ServerSeq),
 			reqPack.Changes,
 			nil,
@@ -165,11 +155,11 @@ func pullSnapshot(
 		clientInfo.ID,
 		reqPack.Checkpoint.ServerSeq+1,
 		initialServerSeq,
-		docInfo.CombinedKey,
+		docInfo.Key,
 		cpAfterPull.String(),
 	)
 
-	return NewServerPack(docKey, cpAfterPull, nil, snapshot), err
+	return NewServerPack(docInfo.Key, cpAfterPull, nil, snapshot), err
 }
 
 func pullChangeInfos(
@@ -200,7 +190,7 @@ func pullChangeInfos(
 			len(pulledChanges),
 			pulledChanges[0].ServerSeq,
 			pulledChanges[len(pulledChanges)-1].ServerSeq,
-			docInfo.CombinedKey,
+			docInfo.Key,
 			cpAfterPull.String(),
 		)
 	}
diff --git a/server/packs/serverpacks.go b/server/packs/serverpacks.go
index e469bd08..14e445ac 100644
--- a/server/packs/serverpacks.go
+++ b/server/packs/serverpacks.go
@@ -108,7 +108,7 @@ func (p *ServerPack) ToPBChangePack() (*api.ChangePack, error) {
 	}
 
 	return &api.ChangePack{
-		DocumentKey:     converter.ToDocumentKey(p.DocumentKey),
+		DocumentKey:     p.DocumentKey.String(),
 		Checkpoint:      converter.ToCheckpoint(p.Checkpoint),
 		Changes:         pbChanges,
 		Snapshot:        p.Snapshot,
diff --git a/server/packs/snapshots.go b/server/packs/snapshots.go
index 6e0fb6a8..afd956cc 100644
--- a/server/packs/snapshots.go
+++ b/server/packs/snapshots.go
@@ -58,13 +58,8 @@ func storeSnapshot(
 	}
 
 	// 03. create document instance of the docInfo
-	docKey, err := docInfo.Key()
-	if err != nil {
-		return err
-	}
-
 	doc, err := document.NewInternalDocumentFromSnapshot(
-		docKey,
+		docInfo.Key,
 		snapshotInfo.ServerSeq,
 		snapshotInfo.Lamport,
 		snapshotInfo.Snapshot,
@@ -74,7 +69,7 @@ func storeSnapshot(
 	}
 
 	pack := change.NewPack(
-		docKey,
+		docInfo.Key,
 		change.InitialCheckpoint.NextServerSeq(docInfo.ServerSeq),
 		changes,
 		nil,
@@ -92,7 +87,7 @@ func storeSnapshot(
 
 	logging.From(ctx).Infof(
 		"SNAP: '%s', serverSeq: %d",
-		docInfo.CombinedKey,
+		docInfo.Key,
 		doc.Checkpoint().ServerSeq,
 	)
 	return nil
diff --git a/server/rpc/auth/auth.go b/server/rpc/auth/auth.go
index 3c871b89..51d78b50 100644
--- a/server/rpc/auth/auth.go
+++ b/server/rpc/auth/auth.go
@@ -35,7 +35,7 @@ func AccessAttributes(pack *change.Pack) []types.AccessAttribute {
 	// NOTE(hackerwins): In the future, methods such as bulk PushPull can be
 	// added, so we declare it as an array.
 	return []types.AccessAttribute{{
-		Key:  pack.DocumentKey.CombinedKey(),
+		Key:  pack.DocumentKey.String(),
 		Verb: verb,
 	}}
 }
diff --git a/server/rpc/yorkie_server.go b/server/rpc/yorkie_server.go
index d2ed7ebb..3081deab 100644
--- a/server/rpc/yorkie_server.go
+++ b/server/rpc/yorkie_server.go
@@ -337,7 +337,7 @@ func (s *yorkieServer) WatchDocuments(
 	var attrs []types.AccessAttribute
 	for _, k := range docKeys {
 		attrs = append(attrs, types.AccessAttribute{
-			Key:  k.CombinedKey(),
+			Key:  k.String(),
 			Verb: types.Read,
 		})
 	}
@@ -440,12 +440,12 @@ func (s *yorkieServer) ListChanges(
 	if err != nil {
 		return nil, err
 	}
-	docKey := converter.FromDocumentKey(req.DocumentKey)
+	docKey := key.Key(req.DocumentKey)
 
 	if err := auth.VerifyAccess(ctx, s.backend, &types.AccessInfo{
 		Method: types.ListChanges,
 		Attributes: []types.AccessAttribute{{
-			Key:  docKey.CombinedKey(),
+			Key:  docKey.String(),
 			Verb: types.Read,
 		}},
 	}); err != nil {


Test patch:
diff --git a/api/converter/converter_test.go b/api/converter/converter_test.go
index 75f4faec..c1d4f1a5 100644
--- a/api/converter/converter_test.go
+++ b/api/converter/converter_test.go
@@ -37,7 +37,7 @@ func TestConverter(t *testing.T) {
 		assert.NoError(t, err)
 		assert.Equal(t, "{}", obj.Marshal())
 
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 
 		err = doc.Update(func(root *proxy.ObjectProxy) error {
 			root.SetNewText("k1").Edit(0, 0, "A")
@@ -62,7 +62,7 @@ func TestConverter(t *testing.T) {
 	})
 
 	t.Run("snapshot test", func(t *testing.T) {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
 			// an object and primitive types
@@ -124,7 +124,7 @@ func TestConverter(t *testing.T) {
 	})
 
 	t.Run("change pack test", func(t *testing.T) {
-		d1 := document.New("c1", "d1")
+		d1 := document.New("d1")
 
 		err := d1.Update(func(root *proxy.ObjectProxy) error {
 			// an object and primitive types
@@ -182,7 +182,7 @@ func TestConverter(t *testing.T) {
 		assert.NoError(t, err)
 		pack.MinSyncedTicket = time.MaxTicket
 
-		d2 := document.New("c1", "d1")
+		d2 := document.New("d1")
 		err = d2.ApplyChangePack(pack)
 		assert.NoError(t, err)
 
diff --git a/pkg/document/document_test.go b/pkg/document/document_test.go
index 87520ff3..72cf7baf 100644
--- a/pkg/document/document_test.go
+++ b/pkg/document/document_test.go
@@ -35,23 +35,23 @@ var (
 
 func TestDocument(t *testing.T) {
 	t.Run("constructor test", func(t *testing.T) {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 		assert.Equal(t, doc.Checkpoint(), change.InitialCheckpoint)
 		assert.False(t, doc.HasLocalChanges())
 		assert.False(t, doc.IsAttached())
 	})
 
 	t.Run("status test", func(t *testing.T) {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 		assert.False(t, doc.IsAttached())
 		doc.SetStatus(document.Attached)
 		assert.True(t, doc.IsAttached())
 	})
 
 	t.Run("equals test", func(t *testing.T) {
-		doc1 := document.New("c1", "d1")
-		doc2 := document.New("c1", "d2")
-		doc3 := document.New("c1", "d3")
+		doc1 := document.New("d1")
+		doc2 := document.New("d2")
+		doc3 := document.New("d3")
 
 		err := doc1.Update(func(root *proxy.ObjectProxy) error {
 			root.SetString("k1", "v1")
@@ -66,7 +66,7 @@ func TestDocument(t *testing.T) {
 	t.Run("nested update test", func(t *testing.T) {
 		expected := `{"k1":"v1","k2":{"k4":"v4"},"k3":["v5","v6"]}`
 
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 		assert.Equal(t, "{}", doc.Marshal())
 		assert.False(t, doc.HasLocalChanges())
 
@@ -84,7 +84,7 @@ func TestDocument(t *testing.T) {
 	})
 
 	t.Run("delete test", func(t *testing.T) {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 		assert.Equal(t, "{}", doc.Marshal())
 		assert.False(t, doc.HasLocalChanges())
 
@@ -110,7 +110,7 @@ func TestDocument(t *testing.T) {
 	})
 
 	t.Run("object test", func(t *testing.T) {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
 			root.SetString("k1", "v1")
 			assert.Equal(t, `{"k1":"v1"}`, root.Marshal())
@@ -123,7 +123,7 @@ func TestDocument(t *testing.T) {
 	})
 
 	t.Run("array test", func(t *testing.T) {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
 			root.SetNewArray("k1").AddInteger(1).AddInteger(2).AddInteger(3)
@@ -161,7 +161,7 @@ func TestDocument(t *testing.T) {
 	})
 
 	t.Run("text test", func(t *testing.T) {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 
 		//           ---------- ins links --------
 		//           |                |          |
@@ -203,7 +203,7 @@ func TestDocument(t *testing.T) {
 	})
 
 	t.Run("text composition test", func(t *testing.T) {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
 			root.SetNewText("k1").
@@ -221,7 +221,7 @@ func TestDocument(t *testing.T) {
 	})
 
 	t.Run("rich text test", func(t *testing.T) {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
 			text := root.SetNewRichText("k1")
@@ -321,7 +321,7 @@ func TestDocument(t *testing.T) {
 	})
 
 	t.Run("counter test", func(t *testing.T) {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 		var integer = 10
 		var long int64 = 5
 		var uinteger uint = 100
@@ -413,7 +413,7 @@ func TestDocument(t *testing.T) {
 	})
 
 	t.Run("rollback test", func(t *testing.T) {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
 			root.SetNewArray("k1").AddInteger(1, 2, 3)
@@ -438,7 +438,7 @@ func TestDocument(t *testing.T) {
 	})
 
 	t.Run("rollback test, primitive deepcopy", func(t *testing.T) {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
 			root.SetNewObject("k1").
@@ -458,7 +458,7 @@ func TestDocument(t *testing.T) {
 	})
 
 	t.Run("text garbage collection test", func(t *testing.T) {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
 			root.SetNewText("text")
@@ -495,7 +495,7 @@ func TestDocument(t *testing.T) {
 	})
 
 	t.Run("previously inserted elements in heap when running GC test", func(t *testing.T) {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
 			root.SetInteger("a", 1)
diff --git a/server/backend/db/memory/db_test.go b/server/backend/db/memory/db_test.go
index 65862c5d..3c47b633 100644
--- a/server/backend/db/memory/db_test.go
+++ b/server/backend/db/memory/db_test.go
@@ -26,6 +26,7 @@ import (
 	"github.com/yorkie-team/yorkie/api/types"
 	"github.com/yorkie-team/yorkie/pkg/document"
 	"github.com/yorkie-team/yorkie/pkg/document/change"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 	"github.com/yorkie-team/yorkie/pkg/document/proxy"
 	"github.com/yorkie-team/yorkie/pkg/document/time"
 	"github.com/yorkie-team/yorkie/server/backend/db"
@@ -86,21 +87,21 @@ func TestDB(t *testing.T) {
 		clientInfo, err := memdb.ActivateClient(ctx, t.Name())
 		assert.NoError(t, err)
 
-		bsonDocKey := fmt.Sprintf("tests$%s", t.Name())
-		_, err = memdb.FindDocInfoByKey(ctx, clientInfo, bsonDocKey, false)
+		docKey := key.Key(fmt.Sprintf("tests$%s", t.Name()))
+		_, err = memdb.FindDocInfoByKey(ctx, clientInfo, docKey, false)
 		assert.ErrorIs(t, err, db.ErrDocumentNotFound)
 
-		docInfo, err := memdb.FindDocInfoByKey(ctx, clientInfo, bsonDocKey, true)
+		docInfo, err := memdb.FindDocInfoByKey(ctx, clientInfo, docKey, true)
 		assert.NoError(t, err)
-		assert.Equal(t, bsonDocKey, docInfo.CombinedKey)
+		assert.Equal(t, docKey, docInfo.Key)
 	})
 
 	t.Run("update clientInfo after PushPull test", func(t *testing.T) {
 		clientInfo, err := memdb.ActivateClient(ctx, t.Name())
 		assert.NoError(t, err)
 
-		bsonDocKey := fmt.Sprintf("tests$%s", t.Name())
-		docInfo, err := memdb.FindDocInfoByKey(ctx, clientInfo, bsonDocKey, true)
+		docKey := key.Key(fmt.Sprintf("tests$%s", t.Name()))
+		docInfo, err := memdb.FindDocInfoByKey(ctx, clientInfo, docKey, true)
 		assert.NoError(t, err)
 
 		err = memdb.UpdateClientInfoAfterPushPull(ctx, clientInfo, docInfo)
@@ -110,16 +111,16 @@ func TestDB(t *testing.T) {
 	})
 
 	t.Run("insert and find changes test", func(t *testing.T) {
-		bsonDocKey := fmt.Sprintf("tests$%s", t.Name())
+		docKey := key.Key(fmt.Sprintf("tests$%s", t.Name()))
 
 		clientInfo, _ := memdb.ActivateClient(ctx, t.Name())
-		docInfo, _ := memdb.FindDocInfoByKey(ctx, clientInfo, bsonDocKey, true)
+		docInfo, _ := memdb.FindDocInfoByKey(ctx, clientInfo, docKey, true)
 		assert.NoError(t, clientInfo.AttachDocument(docInfo.ID))
 		assert.NoError(t, memdb.UpdateClientInfoAfterPushPull(ctx, clientInfo, docInfo))
 
 		bytesID, _ := clientInfo.ID.Bytes()
 		actorID, _ := time.ActorIDFromBytes(bytesID)
-		doc := document.New("tests", t.Name())
+		doc := document.New(key.Key(t.Name()))
 		doc.SetActor(actorID)
 		assert.NoError(t, doc.Update(func(root *proxy.ObjectProxy) error {
 			root.SetNewArray("array")
@@ -132,8 +133,8 @@ func TestDB(t *testing.T) {
 			}))
 		}
 		pack := doc.CreateChangePack()
-		for idx, change := range pack.Changes {
-			change.SetServerSeq(uint64(idx))
+		for idx, c := range pack.Changes {
+			c.SetServerSeq(uint64(idx))
 		}
 
 		// Store changes
@@ -153,14 +154,14 @@ func TestDB(t *testing.T) {
 
 	t.Run("store and find snapshots test", func(t *testing.T) {
 		ctx := context.Background()
-		bsonDocKey := fmt.Sprintf("tests$%s", t.Name())
+		docKey := key.Key(fmt.Sprintf("tests$%s", t.Name()))
 
 		clientInfo, _ := memdb.ActivateClient(ctx, t.Name())
 		bytesID, _ := clientInfo.ID.Bytes()
 		actorID, _ := time.ActorIDFromBytes(bytesID)
-		docInfo, _ := memdb.FindDocInfoByKey(ctx, clientInfo, bsonDocKey, true)
+		docInfo, _ := memdb.FindDocInfoByKey(ctx, clientInfo, docKey, true)
 
-		doc := document.New("tests", t.Name())
+		doc := document.New(key.Key(t.Name()))
 		doc.SetActor(actorID)
 
 		assert.NoError(t, doc.Update(func(root *proxy.ObjectProxy) error {
@@ -197,10 +198,10 @@ func TestDB(t *testing.T) {
 		localDB, err := memory.New()
 		assert.NoError(t, err)
 
-		assertKeys := func(expectedKeys []string, infos []*db.DocInfo) {
-			var keys []string
+		assertKeys := func(expectedKeys []key.Key, infos []*db.DocInfo) {
+			var keys []key.Key
 			for _, info := range infos {
-				keys = append(keys, info.CombinedKey)
+				keys = append(keys, info.Key)
 			}
 			assert.EqualValues(t, expectedKeys, keys)
 		}
@@ -209,19 +210,19 @@ func TestDB(t *testing.T) {
 		totalSize := 9
 		clientInfo, _ := localDB.ActivateClient(ctx, t.Name())
 		for i := 0; i < totalSize; i++ {
-			_, err := localDB.FindDocInfoByKey(ctx, clientInfo, fmt.Sprintf("%d", i), true)
+			_, err := localDB.FindDocInfoByKey(ctx, clientInfo, key.Key(fmt.Sprintf("%d", i)), true)
 			assert.NoError(t, err)
 		}
 
 		// initial page, previousID is empty
 		infos, err := localDB.FindDocInfosByPreviousIDAndPageSize(ctx, "", pageSize, false)
 		assert.NoError(t, err)
-		assertKeys([]string{"8", "7", "6", "5", "4"}, infos)
+		assertKeys([]key.Key{"8", "7", "6", "5", "4"}, infos)
 
 		// backward
 		infos, err = localDB.FindDocInfosByPreviousIDAndPageSize(ctx, infos[len(infos)-1].ID, pageSize, false)
 		assert.NoError(t, err)
-		assertKeys([]string{"3", "2", "1", "0"}, infos)
+		assertKeys([]key.Key{"3", "2", "1", "0"}, infos)
 
 		// backward again
 		emptyInfos, err := localDB.FindDocInfosByPreviousIDAndPageSize(ctx, infos[len(infos)-1].ID, pageSize, false)
@@ -231,7 +232,7 @@ func TestDB(t *testing.T) {
 		// forward
 		infos, err = localDB.FindDocInfosByPreviousIDAndPageSize(ctx, infos[0].ID, pageSize, true)
 		assert.NoError(t, err)
-		assertKeys([]string{"4", "5", "6", "7", "8"}, infos)
+		assertKeys([]key.Key{"4", "5", "6", "7", "8"}, infos)
 
 		// forward again
 		emptyInfos, err = localDB.FindDocInfosByPreviousIDAndPageSize(ctx, infos[len(infos)-1].ID, pageSize, true)
diff --git a/server/backend/sync/memory/pubsub_test.go b/server/backend/sync/memory/pubsub_test.go
index a10fe888..0b883ab0 100644
--- a/server/backend/sync/memory/pubsub_test.go
+++ b/server/backend/sync/memory/pubsub_test.go
@@ -28,7 +28,6 @@ import (
 	"github.com/yorkie-team/yorkie/pkg/document/time"
 	"github.com/yorkie-team/yorkie/server/backend/sync"
 	"github.com/yorkie-team/yorkie/server/backend/sync/memory"
-	"github.com/yorkie-team/yorkie/test/helper"
 )
 
 func TestPubSub(t *testing.T) {
@@ -41,12 +40,7 @@ func TestPubSub(t *testing.T) {
 
 	t.Run("publish subscribe test", func(t *testing.T) {
 		pubSub := memory.NewPubSub()
-		docKeys := []key.Key{
-			{
-				Collection: helper.Collection,
-				Document:   t.Name(),
-			},
-		}
+		docKeys := []key.Key{key.Key(t.Name())}
 		event := sync.DocEvent{
 			Type:         types.DocumentsWatchedEvent,
 			Publisher:    actorB,
@@ -76,12 +70,7 @@ func TestPubSub(t *testing.T) {
 
 	t.Run("subscriptions map test", func(t *testing.T) {
 		pubSub := memory.NewPubSub()
-		docKeys := []key.Key{
-			{
-				Collection: helper.Collection,
-				Document:   t.Name(),
-			},
-		}
+		docKeys := []key.Key{key.Key(t.Name())}
 
 		ctx := context.Background()
 
@@ -90,7 +79,7 @@ func TestPubSub(t *testing.T) {
 			assert.NoError(t, err)
 
 			subs := pubSub.BuildPeersMap(docKeys)
-			assert.Len(t, subs[docKeys[0].CombinedKey()], i+1)
+			assert.Len(t, subs[docKeys[0].String()], i+1)
 		}
 	})
 }
diff --git a/server/rpc/server_test.go b/server/rpc/server_test.go
index f1c1d54d..0bf202fd 100644
--- a/server/rpc/server_test.go
+++ b/server/rpc/server_test.go
@@ -52,10 +52,8 @@ var (
 	testClient    api.YorkieClient
 
 	invalidChangePack = &api.ChangePack{
-		DocumentKey: &api.DocumentKey{
-			Collection: "invalid", Document: "invalid",
-		},
-		Checkpoint: nil,
+		DocumentKey: "invalid",
+		Checkpoint:  nil,
 	}
 )
 
@@ -167,10 +165,8 @@ func TestRPCServerBackend(t *testing.T) {
 		assert.NoError(t, err)
 
 		packWithNoChanges := &api.ChangePack{
-			DocumentKey: &api.DocumentKey{
-				Collection: t.Name(), Document: t.Name(),
-			},
-			Checkpoint: &api.Checkpoint{ServerSeq: 0, ClientSeq: 0},
+			DocumentKey: t.Name(),
+			Checkpoint:  &api.Checkpoint{ServerSeq: 0, ClientSeq: 0},
 		}
 
 		_, err = testClient.AttachDocument(
@@ -256,10 +252,8 @@ func TestRPCServerBackend(t *testing.T) {
 			&api.DetachDocumentRequest{
 				ClientId: activateResp.ClientId,
 				ChangePack: &api.ChangePack{
-					DocumentKey: &api.DocumentKey{
-						Collection: "invalid", Document: "invalid",
-					},
-					Checkpoint: &api.Checkpoint{ServerSeq: 0, ClientSeq: 0},
+					DocumentKey: "invalid",
+					Checkpoint:  &api.Checkpoint{ServerSeq: 0, ClientSeq: 0},
 				},
 			},
 		)
@@ -284,10 +278,8 @@ func TestRPCServerBackend(t *testing.T) {
 
 	t.Run("push/pull changes test", func(t *testing.T) {
 		packWithNoChanges := &api.ChangePack{
-			DocumentKey: &api.DocumentKey{
-				Collection: t.Name(), Document: t.Name(),
-			},
-			Checkpoint: &api.Checkpoint{ServerSeq: 0, ClientSeq: 0},
+			DocumentKey: t.Name(),
+			Checkpoint:  &api.Checkpoint{ServerSeq: 0, ClientSeq: 0},
 		}
 
 		activateResp, err := testClient.ActivateClient(
@@ -301,10 +293,8 @@ func TestRPCServerBackend(t *testing.T) {
 			&api.AttachDocumentRequest{
 				ClientId: activateResp.ClientId,
 				ChangePack: &api.ChangePack{
-					DocumentKey: &api.DocumentKey{
-						Collection: t.Name(), Document: t.Name(),
-					},
-					Checkpoint: &api.Checkpoint{ServerSeq: 0, ClientSeq: 1},
+					DocumentKey: t.Name(),
+					Checkpoint:  &api.Checkpoint{ServerSeq: 0, ClientSeq: 1},
 					Changes: []*api.Change{{
 						Id: &api.ChangeID{
 							ClientSeq: 1,
@@ -322,10 +312,8 @@ func TestRPCServerBackend(t *testing.T) {
 			&api.PushPullRequest{
 				ClientId: activateResp.ClientId,
 				ChangePack: &api.ChangePack{
-					DocumentKey: &api.DocumentKey{
-						Collection: t.Name(), Document: t.Name(),
-					},
-					Checkpoint: &api.Checkpoint{ServerSeq: 0, ClientSeq: 2},
+					DocumentKey: t.Name(),
+					Checkpoint:  &api.Checkpoint{ServerSeq: 0, ClientSeq: 2},
 					Changes: []*api.Change{{
 						Id: &api.ChangeID{
 							ClientSeq: 2,
@@ -343,10 +331,8 @@ func TestRPCServerBackend(t *testing.T) {
 			&api.DetachDocumentRequest{
 				ClientId: activateResp.ClientId,
 				ChangePack: &api.ChangePack{
-					DocumentKey: &api.DocumentKey{
-						Collection: t.Name(), Document: t.Name(),
-					},
-					Checkpoint: &api.Checkpoint{ServerSeq: 0, ClientSeq: 3},
+					DocumentKey: t.Name(),
+					Checkpoint:  &api.Checkpoint{ServerSeq: 0, ClientSeq: 3},
 					Changes: []*api.Change{{
 						Id: &api.ChangeID{
 							ClientSeq: 3,
diff --git a/test/bench/document_bench_test.go b/test/bench/document_bench_test.go
index 0dd2c182..744d6c71 100644
--- a/test/bench/document_bench_test.go
+++ b/test/bench/document_bench_test.go
@@ -33,7 +33,7 @@ import (
 func BenchmarkDocument(b *testing.B) {
 	b.Run("constructor test", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
-			doc := document.New("c1", "d1")
+			doc := document.New("d1")
 			assert.Equal(b, doc.Checkpoint(), change.InitialCheckpoint)
 			assert.False(b, doc.HasLocalChanges())
 			assert.False(b, doc.IsAttached())
@@ -42,7 +42,7 @@ func BenchmarkDocument(b *testing.B) {
 
 	b.Run("status test", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
-			doc := document.New("c1", "d1")
+			doc := document.New("d1")
 			assert.False(b, doc.IsAttached())
 			doc.SetStatus(document.Attached)
 			assert.True(b, doc.IsAttached())
@@ -51,9 +51,9 @@ func BenchmarkDocument(b *testing.B) {
 
 	b.Run("equals test", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
-			doc1 := document.New("c1", "d1")
-			doc2 := document.New("c1", "d2")
-			doc3 := document.New("c1", "d3")
+			doc1 := document.New("d1")
+			doc2 := document.New("d2")
+			doc3 := document.New("d3")
 
 			err := doc1.Update(func(root *proxy.ObjectProxy) error {
 				root.SetString("k1", "v1")
@@ -70,7 +70,7 @@ func BenchmarkDocument(b *testing.B) {
 		for i := 0; i < b.N; i++ {
 			expected := `{"k1":"v1","k2":{"k4":"v4"},"k3":["v5","v6"]}`
 
-			doc := document.New("c1", "d1")
+			doc := document.New("d1")
 			assert.Equal(b, "{}", doc.Marshal())
 			assert.False(b, doc.HasLocalChanges())
 
@@ -90,7 +90,7 @@ func BenchmarkDocument(b *testing.B) {
 
 	b.Run("delete test", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
-			doc := document.New("c1", "d1")
+			doc := document.New("d1")
 			assert.Equal(b, "{}", doc.Marshal())
 			assert.False(b, doc.HasLocalChanges())
 
@@ -118,7 +118,7 @@ func BenchmarkDocument(b *testing.B) {
 
 	b.Run("object test", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
-			doc := document.New("c1", "d1")
+			doc := document.New("d1")
 			err := doc.Update(func(root *proxy.ObjectProxy) error {
 				root.SetString("k1", "v1")
 				assert.Equal(b, `{"k1":"v1"}`, root.Marshal())
@@ -133,7 +133,7 @@ func BenchmarkDocument(b *testing.B) {
 
 	b.Run("array test", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
-			doc := document.New("c1", "d1")
+			doc := document.New("d1")
 
 			err := doc.Update(func(root *proxy.ObjectProxy) error {
 				root.SetNewArray("k1").AddInteger(1).AddInteger(2).AddInteger(3)
@@ -173,7 +173,7 @@ func BenchmarkDocument(b *testing.B) {
 
 	b.Run("text test", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
-			doc := document.New("c1", "d1")
+			doc := document.New("d1")
 
 			//           ---------- ins links --------
 			//           |                |          |
@@ -217,7 +217,7 @@ func BenchmarkDocument(b *testing.B) {
 
 	b.Run("text composition test", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
-			doc := document.New("c1", "d1")
+			doc := document.New("d1")
 
 			err := doc.Update(func(root *proxy.ObjectProxy) error {
 				root.SetNewText("k1").
@@ -237,7 +237,7 @@ func BenchmarkDocument(b *testing.B) {
 
 	b.Run("rich text test", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
-			doc := document.New("c1", "d1")
+			doc := document.New("d1")
 
 			err := doc.Update(func(root *proxy.ObjectProxy) error {
 				text := root.SetNewRichText("k1")
@@ -339,7 +339,7 @@ func BenchmarkDocument(b *testing.B) {
 
 	b.Run("counter test", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
-			doc := document.New("c1", "d1")
+			doc := document.New("d1")
 			var integer = 10
 			var long int64 = 5
 			var uinteger uint = 100
@@ -498,7 +498,7 @@ func BenchmarkDocument(b *testing.B) {
 
 func benchmarkText(cnt int, b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
 			text := root.SetNewText("k1")
@@ -513,7 +513,7 @@ func benchmarkText(cnt int, b *testing.B) {
 
 func benchmarkTextEditGC(cnt int, b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 		assert.Equal(b, "{}", doc.Marshal())
 		assert.False(b, doc.HasLocalChanges())
 
@@ -541,7 +541,7 @@ func benchmarkTextEditGC(cnt int, b *testing.B) {
 
 func benchmarkTextSplitGC(cnt int, b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 		assert.Equal(b, "{}", doc.Marshal())
 		assert.False(b, doc.HasLocalChanges())
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
@@ -573,7 +573,7 @@ func benchmarkTextSplitGC(cnt int, b *testing.B) {
 
 func benchmarkArray(cnt int, b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
 			array := root.SetNewArray("k1")
@@ -588,7 +588,7 @@ func benchmarkArray(cnt int, b *testing.B) {
 
 func benchmarkArrayGC(cnt int, b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
 			root.SetNewArray("1")
 			for i := 0; i < cnt; i++ {
@@ -612,7 +612,7 @@ func benchmarkArrayGC(cnt int, b *testing.B) {
 
 func benchmarkCounter(cnt int, b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
 			counter := root.SetNewCounter("k1", 0)
@@ -627,7 +627,7 @@ func benchmarkCounter(cnt int, b *testing.B) {
 
 func benchmarkRichText(cnt int, b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
 			text := root.SetNewRichText("k1")
@@ -642,7 +642,7 @@ func benchmarkRichText(cnt int, b *testing.B) {
 
 func benchmarkObject(cnt int, b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		doc := document.New("c1", "d1")
+		doc := document.New("d1")
 
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
 			for c := 0; c < cnt; c++ {
diff --git a/test/bench/text_editing_bench_test.go b/test/bench/text_editing_bench_test.go
index 59b570f9..8ad77342 100644
--- a/test/bench/text_editing_bench_test.go
+++ b/test/bench/text_editing_bench_test.go
@@ -40,7 +40,7 @@ func BenchmarkTextEditing(b *testing.B) {
 
 	b.StartTimer()
 
-	doc := document.New("c1", "d1")
+	doc := document.New("d1")
 	err = doc.Update(func(root *proxy.ObjectProxy) error {
 		root.SetNewText("text")
 		return nil
diff --git a/test/helper/helper.go b/test/helper/helper.go
index bbb0b248..8d02f759 100644
--- a/test/helper/helper.go
+++ b/test/helper/helper.go
@@ -62,8 +62,6 @@ var (
 	ETCDEndpoints     = []string{"localhost:2379"}
 	ETCDDialTimeout   = 5 * gotime.Second
 	ETCDLockLeaseTime = 30 * gotime.Second
-
-	Collection = "test-collection"
 )
 
 func init() {
diff --git a/test/integration/agent_test.go b/test/integration/agent_test.go
index 28d1fdd0..d5dc5d71 100644
--- a/test/integration/agent_test.go
+++ b/test/integration/agent_test.go
@@ -30,6 +30,7 @@ import (
 
 	"github.com/yorkie-team/yorkie/client"
 	"github.com/yorkie-team/yorkie/pkg/document"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 	"github.com/yorkie-team/yorkie/test/helper"
 )
 
@@ -43,7 +44,7 @@ func TestServer(t *testing.T) {
 		assert.NoError(t, err)
 		assert.NoError(t, cli.Activate(ctx))
 
-		doc := document.New(helper.Collection, t.Name())
+		doc := document.New(key.Key(t.Name()))
 		assert.NoError(t, cli.Attach(ctx, doc))
 
 		wg := sync.WaitGroup{}
@@ -58,7 +59,7 @@ func TestServer(t *testing.T) {
 					return
 				case wr := <-wrch:
 					if wr.Err == io.EOF || status.Code(wr.Err) == codes.Canceled {
-						peers := wr.PeersMapByDoc[doc.Key().CombinedKey()]
+						peers := wr.PeersMapByDoc[doc.Key().String()]
 						assert.Len(t, peers, 0)
 						wg.Done()
 						return
diff --git a/test/integration/array_test.go b/test/integration/array_test.go
index ed6a6e74..e6658db9 100644
--- a/test/integration/array_test.go
+++ b/test/integration/array_test.go
@@ -25,8 +25,8 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"github.com/yorkie-team/yorkie/pkg/document"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 	"github.com/yorkie-team/yorkie/pkg/document/proxy"
-	"github.com/yorkie-team/yorkie/test/helper"
 )
 
 func TestArray(t *testing.T) {
@@ -36,7 +36,7 @@ func TestArray(t *testing.T) {
 
 	t.Run("causal nested array test", func(t *testing.T) {
 		ctx := context.Background()
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
@@ -48,7 +48,7 @@ func TestArray(t *testing.T) {
 		}, "nested update by c1")
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
@@ -58,7 +58,7 @@ func TestArray(t *testing.T) {
 	t.Run("concurrent array add/delete simple test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
@@ -71,7 +71,7 @@ func TestArray(t *testing.T) {
 		err = c1.Sync(ctx)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
@@ -93,7 +93,7 @@ func TestArray(t *testing.T) {
 	t.Run("concurrent array add/delete test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
@@ -105,7 +105,7 @@ func TestArray(t *testing.T) {
 		err = c1.Sync(ctx)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
@@ -128,7 +128,7 @@ func TestArray(t *testing.T) {
 	t.Run("concurrent array delete test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
@@ -140,7 +140,7 @@ func TestArray(t *testing.T) {
 		err = c1.Sync(ctx)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
@@ -168,7 +168,7 @@ func TestArray(t *testing.T) {
 	t.Run("concurrent array move test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
@@ -181,7 +181,7 @@ func TestArray(t *testing.T) {
 		err = c1.Sync(ctx)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
@@ -209,7 +209,7 @@ func TestArray(t *testing.T) {
 	t.Run("concurrent array move with the same position test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		assert.NoError(t, c1.Attach(ctx, d1))
 		assert.NoError(t, d1.Update(func(root *proxy.ObjectProxy) error {
 			root.SetNewArray("k1").AddInteger(0, 1, 2)
@@ -217,7 +217,7 @@ func TestArray(t *testing.T) {
 			return nil
 		}))
 		assert.NoError(t, c1.Sync(ctx))
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		assert.NoError(t, c2.Attach(ctx, d2))
 
 		assert.NoError(t, d1.Update(func(root *proxy.ObjectProxy) error {
diff --git a/test/integration/auth_webhook_test.go b/test/integration/auth_webhook_test.go
index 88e936d2..7a4efbc3 100644
--- a/test/integration/auth_webhook_test.go
+++ b/test/integration/auth_webhook_test.go
@@ -34,6 +34,7 @@ import (
 	"github.com/yorkie-team/yorkie/api/types"
 	"github.com/yorkie-team/yorkie/client"
 	"github.com/yorkie-team/yorkie/pkg/document"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 	"github.com/yorkie-team/yorkie/pkg/document/proxy"
 	"github.com/yorkie-team/yorkie/server"
 	"github.com/yorkie-team/yorkie/test/helper"
@@ -110,7 +111,7 @@ func TestProjectAuthWebhook(t *testing.T) {
 		assert.NoError(t, cli.Activate(ctx))
 		defer func() { assert.NoError(t, cli.Deactivate(ctx)) }()
 
-		doc := document.New(helper.Collection, t.Name())
+		doc := document.New(key.Key(t.Name()))
 		assert.NoError(t, cli.Attach(ctx, doc))
 
 		// client without token
@@ -158,7 +159,7 @@ func TestProjectAuthWebhook(t *testing.T) {
 		err = cli.Activate(ctx)
 		assert.NoError(t, err)
 
-		doc := document.New(helper.Collection, t.Name())
+		doc := document.New(key.Key(t.Name()))
 		err = cli.Attach(ctx, doc)
 		assert.Equal(t, codes.Unauthenticated, status.Convert(err).Code())
 
@@ -202,7 +203,7 @@ func TestAuthWebhook(t *testing.T) {
 		err = cli.Activate(ctx)
 		assert.NoError(t, err)
 
-		doc := document.New(helper.Collection, t.Name())
+		doc := document.New(key.Key(t.Name()))
 		err = cli.Attach(ctx, doc)
 		assert.NoError(t, err)
 	})
@@ -285,7 +286,7 @@ func TestAuthWebhook(t *testing.T) {
 		err = cli.Activate(ctx)
 		assert.NoError(t, err)
 
-		doc := document.New(helper.Collection, t.Name())
+		doc := document.New(key.Key(t.Name()))
 		err = cli.Attach(ctx, doc)
 		assert.NoError(t, err)
 
diff --git a/test/integration/cluster_mode_test.go b/test/integration/cluster_mode_test.go
index e51bb18a..56668e6a 100644
--- a/test/integration/cluster_mode_test.go
+++ b/test/integration/cluster_mode_test.go
@@ -31,6 +31,7 @@ import (
 	"github.com/yorkie-team/yorkie/api/types"
 	"github.com/yorkie-team/yorkie/client"
 	"github.com/yorkie-team/yorkie/pkg/document"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 	"github.com/yorkie-team/yorkie/pkg/document/proxy"
 	"github.com/yorkie-team/yorkie/server/backend/sync"
 	"github.com/yorkie-team/yorkie/test/helper"
@@ -81,8 +82,8 @@ func withTwoClientsAndDocsInClusterMode(
 		assert.NoError(t, client2.Close())
 	}()
 
-	doc1 := document.New(helper.Collection, t.Name())
-	doc2 := document.New(helper.Collection, t.Name())
+	doc1 := document.New(key.Key(t.Name()))
+	doc2 := document.New(key.Key(t.Name()))
 
 	assert.NoError(t, client1.Attach(ctx, doc1))
 	assert.NoError(t, client2.Attach(ctx, doc2))
@@ -143,7 +144,7 @@ func TestClusterMode(t *testing.T) {
 						assert.NoError(t, wr.Err)
 
 						if wr.Type == client.PeersChanged {
-							peers := wr.PeersMapByDoc[d1.Key().CombinedKey()]
+							peers := wr.PeersMapByDoc[d1.Key().String()]
 							responsePairs = append(responsePairs, watchResponsePair{
 								Type:  wr.Type,
 								Peers: peers,
diff --git a/test/integration/counter_test.go b/test/integration/counter_test.go
index 3c219d32..b0fd97ee 100644
--- a/test/integration/counter_test.go
+++ b/test/integration/counter_test.go
@@ -26,8 +26,8 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"github.com/yorkie-team/yorkie/pkg/document"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 	"github.com/yorkie-team/yorkie/pkg/document/proxy"
-	"github.com/yorkie-team/yorkie/test/helper"
 )
 
 func TestCounter(t *testing.T) {
@@ -37,7 +37,7 @@ func TestCounter(t *testing.T) {
 
 	t.Run("causal counter.increase test", func(t *testing.T) {
 		ctx := context.Background()
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
@@ -52,7 +52,7 @@ func TestCounter(t *testing.T) {
 		}, "nested update by c1")
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
@@ -62,7 +62,7 @@ func TestCounter(t *testing.T) {
 	t.Run("concurrent counter increase test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
@@ -76,7 +76,7 @@ func TestCounter(t *testing.T) {
 		err = c1.Sync(ctx)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
diff --git a/test/integration/document_test.go b/test/integration/document_test.go
index e26d9dcc..e79f3b20 100644
--- a/test/integration/document_test.go
+++ b/test/integration/document_test.go
@@ -28,8 +28,8 @@ import (
 
 	"github.com/yorkie-team/yorkie/client"
 	"github.com/yorkie-team/yorkie/pkg/document"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 	"github.com/yorkie-team/yorkie/pkg/document/proxy"
-	"github.com/yorkie-team/yorkie/test/helper"
 )
 
 func TestDocument(t *testing.T) {
@@ -39,7 +39,7 @@ func TestDocument(t *testing.T) {
 
 	t.Run("attach/detach test", func(t *testing.T) {
 		ctx := context.Background()
-		doc := document.New(helper.Collection, t.Name())
+		doc := document.New(key.Key(t.Name()))
 		err := doc.Update(func(root *proxy.ObjectProxy) error {
 			root.SetString("k1", "v1")
 			return nil
@@ -54,7 +54,7 @@ func TestDocument(t *testing.T) {
 		assert.NoError(t, err)
 		assert.False(t, doc.IsAttached())
 
-		doc2 := document.New(helper.Collection, t.Name())
+		doc2 := document.New(key.Key(t.Name()))
 		err = doc2.Update(func(root *proxy.ObjectProxy) error {
 			root.SetString("k1", "v2")
 			return nil
@@ -69,11 +69,11 @@ func TestDocument(t *testing.T) {
 	t.Run("concurrent complex test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
@@ -108,11 +108,11 @@ func TestDocument(t *testing.T) {
 	t.Run("watch document changed event test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
diff --git a/test/integration/gc_test.go b/test/integration/gc_test.go
index eec08925..0a2c3ca4 100644
--- a/test/integration/gc_test.go
+++ b/test/integration/gc_test.go
@@ -25,8 +25,8 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"github.com/yorkie-team/yorkie/pkg/document"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 	"github.com/yorkie-team/yorkie/pkg/document/proxy"
-	"github.com/yorkie-team/yorkie/test/helper"
 )
 
 func TestGarbageCollection(t *testing.T) {
@@ -37,11 +37,11 @@ func TestGarbageCollection(t *testing.T) {
 	t.Run("garbage collection for container type test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
@@ -105,11 +105,11 @@ func TestGarbageCollection(t *testing.T) {
 	t.Run("garbage collection for text type test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
@@ -178,11 +178,11 @@ func TestGarbageCollection(t *testing.T) {
 	t.Run("garbage collection with detached document test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
diff --git a/test/integration/history_test.go b/test/integration/history_test.go
index d1970532..668145a6 100644
--- a/test/integration/history_test.go
+++ b/test/integration/history_test.go
@@ -25,8 +25,8 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"github.com/yorkie-team/yorkie/pkg/document"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 	"github.com/yorkie-team/yorkie/pkg/document/proxy"
-	"github.com/yorkie-team/yorkie/test/helper"
 )
 
 func TestHistory(t *testing.T) {
@@ -37,7 +37,7 @@ func TestHistory(t *testing.T) {
 	t.Run("history test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		assert.NoError(t, c1.Attach(ctx, d1))
 		defer func() { assert.NoError(t, c1.Detach(ctx, d1)) }()
 
diff --git a/test/integration/object_test.go b/test/integration/object_test.go
index 95957b70..395d541e 100644
--- a/test/integration/object_test.go
+++ b/test/integration/object_test.go
@@ -25,8 +25,8 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"github.com/yorkie-team/yorkie/pkg/document"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 	"github.com/yorkie-team/yorkie/pkg/document/proxy"
-	"github.com/yorkie-team/yorkie/test/helper"
 )
 
 func TestObject(t *testing.T) {
@@ -37,11 +37,11 @@ func TestObject(t *testing.T) {
 	t.Run("causal object.set/delete test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
@@ -70,7 +70,7 @@ func TestObject(t *testing.T) {
 
 	t.Run("concurrent object set/delete simple test", func(t *testing.T) {
 		ctx := context.Background()
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
@@ -83,7 +83,7 @@ func TestObject(t *testing.T) {
 		err = c1.Sync(ctx)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
@@ -107,11 +107,11 @@ func TestObject(t *testing.T) {
 
 	t.Run("concurrent object.set test", func(t *testing.T) {
 		ctx := context.Background()
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
diff --git a/test/integration/peer_awareness_test.go b/test/integration/peer_awareness_test.go
index bdebc18b..4d0dee4c 100644
--- a/test/integration/peer_awareness_test.go
+++ b/test/integration/peer_awareness_test.go
@@ -29,7 +29,7 @@ import (
 	"github.com/yorkie-team/yorkie/api/types"
 	"github.com/yorkie-team/yorkie/client"
 	"github.com/yorkie-team/yorkie/pkg/document"
-	"github.com/yorkie-team/yorkie/test/helper"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 )
 
 func TestPeerAwareness(t *testing.T) {
@@ -40,8 +40,8 @@ func TestPeerAwareness(t *testing.T) {
 	t.Run("WatchStarted and PeersChanged event test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
-		d2 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
+		d2 := document.New(key.Key(t.Name()))
 		assert.NoError(t, c1.Attach(ctx, d1))
 		defer func() { assert.NoError(t, c1.Detach(ctx, d1)) }()
 		assert.NoError(t, c2.Attach(ctx, d2))
@@ -73,7 +73,7 @@ func TestPeerAwareness(t *testing.T) {
 					}
 
 					if wr.Type == client.PeersChanged {
-						peers := wr.PeersMapByDoc[d1.Key().CombinedKey()]
+						peers := wr.PeersMapByDoc[d1.Key().String()]
 						responsePairs = append(responsePairs, watchResponsePair{
 							Type:  wr.Type,
 							Peers: peers,
diff --git a/test/integration/primitive_test.go b/test/integration/primitive_test.go
index a2c9d4d9..281b9d2c 100644
--- a/test/integration/primitive_test.go
+++ b/test/integration/primitive_test.go
@@ -26,8 +26,8 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"github.com/yorkie-team/yorkie/pkg/document"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 	"github.com/yorkie-team/yorkie/pkg/document/proxy"
-	"github.com/yorkie-team/yorkie/test/helper"
 )
 
 func TestPrimitive(t *testing.T) {
@@ -37,7 +37,7 @@ func TestPrimitive(t *testing.T) {
 
 	t.Run("causal primitive data test", func(t *testing.T) {
 		ctx := context.Background()
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
@@ -64,7 +64,7 @@ func TestPrimitive(t *testing.T) {
 		}, "nested update by c1")
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
diff --git a/test/integration/snapshot_test.go b/test/integration/snapshot_test.go
index b2fbf531..dc4ddbe6 100644
--- a/test/integration/snapshot_test.go
+++ b/test/integration/snapshot_test.go
@@ -27,6 +27,7 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"github.com/yorkie-team/yorkie/pkg/document"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 	"github.com/yorkie-team/yorkie/pkg/document/proxy"
 	"github.com/yorkie-team/yorkie/test/helper"
 )
@@ -39,11 +40,11 @@ func TestSnapshot(t *testing.T) {
 	t.Run("snapshot test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
@@ -78,7 +79,7 @@ func TestSnapshot(t *testing.T) {
 	t.Run("text snapshot test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
@@ -112,7 +113,7 @@ func TestSnapshot(t *testing.T) {
 		err = c1.Sync(ctx)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
diff --git a/test/integration/text_test.go b/test/integration/text_test.go
index 9c6c178a..3a991222 100644
--- a/test/integration/text_test.go
+++ b/test/integration/text_test.go
@@ -25,8 +25,8 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"github.com/yorkie-team/yorkie/pkg/document"
+	"github.com/yorkie-team/yorkie/pkg/document/key"
 	"github.com/yorkie-team/yorkie/pkg/document/proxy"
-	"github.com/yorkie-team/yorkie/test/helper"
 )
 
 func TestText(t *testing.T) {
@@ -37,7 +37,7 @@ func TestText(t *testing.T) {
 	t.Run("text test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
@@ -49,7 +49,7 @@ func TestText(t *testing.T) {
 		err = c1.Sync(ctx)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)
 
@@ -99,7 +99,7 @@ func TestText(t *testing.T) {
 	t.Run("rich text test", func(t *testing.T) {
 		ctx := context.Background()
 
-		d1 := document.New(helper.Collection, t.Name())
+		d1 := document.New(key.Key(t.Name()))
 		err := c1.Attach(ctx, d1)
 		assert.NoError(t, err)
 
@@ -111,7 +111,7 @@ func TestText(t *testing.T) {
 		err = c1.Sync(ctx)
 		assert.NoError(t, err)
 
-		d2 := document.New(helper.Collection, t.Name())
+		d2 := document.New(key.Key(t.Name()))
 		err = c2.Attach(ctx, d2)
 		assert.NoError(t, err)