diff --git a/id/_bson_test.go b/id/_bson_test.go
deleted file mode 100644
index 43c09e476d3b15565b83d73623e39bd814f1f6b3..0000000000000000000000000000000000000000
--- a/id/_bson_test.go
+++ /dev/null
@@ -1,107 +0,0 @@
-package id
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"go.mongodb.org/mongo-driver/bson"
-)
-
-func TestID_MarshalUnmarshalBSON(t *testing.T) {
-	tests := []struct {
-		name string
-		id   *ID
-	}{
-		{
-			name: "OrganizationID",
-			id:   &ID{Descriptor: &OrganizationID{OrganizationID: "1"}},
-		},
-		{
-			name: "UserID",
-			id:   &ID{Descriptor: &UserID{UserID: "1"}},
-		},
-		{
-			name: "ServiceID",
-			id:   &ID{Descriptor: &ServiceID{ServiceID: "1"}},
-		},
-		{
-			name: "SpaceId",
-			id:   &ID{Descriptor: &SpaceID{SpaceID: "1"}},
-		},
-		{
-			name: "EnvironmentID",
-			id:   &ID{Descriptor: &EnvironmentID{EnvironmentID: "1", SpaceID: SpaceID{SpaceID: "1"}}},
-		},
-		{
-			name: "ClientID",
-			id:   &ID{Descriptor: &ClientID{ClientID: "1", SpaceID: SpaceID{SpaceID: "1"}}},
-		},
-		{
-			name: "RoleID",
-			id:   &ID{Descriptor: &RoleID{RoleID: "1", SpaceID: SpaceID{SpaceID: "1"}}},
-		},
-		{
-			name: "CollectionId",
-			id:   &ID{Descriptor: &CollectionId{CollectionID: "1", EnvironmentId: EnvironmentID{EnvironmentID: "1", SpaceID: SpaceID{SpaceID: "1"}}}},
-		},
-		{
-			name: "SchemaID",
-			id:   &ID{Descriptor: &SchemaID{CollectionId: "1", EnvironmentID: EnvironmentID{EnvironmentID: "1", SpaceID: SpaceID{SpaceID: "1"}}}},
-		},
-		{
-			name: "ItemId",
-			id:   &ID{Descriptor: &ItemId{ItemID: "1", CollectionId: CollectionId{CollectionID: "1", EnvironmentId: EnvironmentID{EnvironmentID: "1", SpaceID: SpaceID{SpaceID: "1"}}}}},
-		},
-		{
-			name: "RevisionID",
-			id:   &ID{Descriptor: &RevisionID{RevisionID: "1", ItemId: ItemId{ItemID: "1", CollectionId: CollectionId{CollectionID: "1", EnvironmentId: EnvironmentID{EnvironmentID: "1", SpaceID: SpaceID{SpaceID: "1"}}}}}},
-		},
-		{
-			name: "FieldId",
-			id:   &ID{Descriptor: &FieldId{FieldName: "1", ItemId: ItemId{ItemID: "1", CollectionId: CollectionId{CollectionID: "1", EnvironmentId: EnvironmentID{EnvironmentID: "1", SpaceID: SpaceID{SpaceID: "1"}}}}}},
-		},
-		{
-			name: "SystemID",
-			id:   &ID{Descriptor: &SystemID{}},
-		},
-	}
-	type test struct {
-		Text string
-		ID   *ID
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			s := &test{Text: tt.name, ID: tt.id}
-
-			b, err := bson.Marshal(s)
-			require.NoError(t, err)
-
-			var v *test
-			require.NoError(t, bson.Unmarshal(b, &v))
-			assert.Equal(t, s, v, "после Unmarshal объект должен быть идентичен исходному")
-		})
-	}
-}
-
-func TestID_ExampleBSON(t *testing.T) {
-	type data struct {
-		ID     *ID
-		Text   string
-		Number int
-	}
-
-	test := &data{
-		ID:     &ID{Descriptor: &SpaceID{SpaceID: Space}},
-		Text:   "text",
-		Number: 1,
-	}
-
-	b, err := bson.Marshal(test)
-	require.NoError(t, err)
-
-	buf := new(data)
-	err = bson.Unmarshal(b, &buf)
-	require.NoError(t, err)
-	assert.Equal(t, test, buf, "после Unmarshal объект должен совпадать с исходным")
-}
diff --git a/id/_json_test.go b/id/_json_test.go
deleted file mode 100644
index 811df1c0e16c1cd9c2cb200264a47df36f1b7330..0000000000000000000000000000000000000000
--- a/id/_json_test.go
+++ /dev/null
@@ -1,101 +0,0 @@
-package id
-
-import (
-	"testing"
-
-	jsoniter "github.com/json-iterator/go"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestID_MarshalUnmarshalJSON(t *testing.T) {
-	tests := []struct {
-		name string
-		id   *ID
-	}{
-		{
-			name: "OrganizationID",
-			id:   &ID{Descriptor: &OrganizationID{OrganizationID: "1"}},
-		},
-		{
-			name: "UserID",
-			id:   &ID{Descriptor: &UserID{UserID: "1"}},
-		},
-		{
-			name: "ServiceID",
-			id:   &ID{Descriptor: &ServiceID{ServiceID: "1"}},
-		},
-		{
-			name: "SpaceId",
-			id:   &ID{Descriptor: &SpaceID{SpaceID: "1"}},
-		},
-		{
-			name: "EnvironmentID",
-			id:   &ID{Descriptor: &EnvironmentID{EnvironmentID: "1", SpaceID: SpaceID{SpaceID: "1"}}},
-		},
-		{
-			name: "ClientID",
-			id:   &ID{Descriptor: &ClientID{ClientID: "1", SpaceID: SpaceID{SpaceID: "1"}}},
-		},
-		{
-			name: "RoleID",
-			id:   &ID{Descriptor: &RoleID{RoleID: "1", SpaceID: SpaceID{SpaceID: "1"}}},
-		},
-		{
-			name: "CollectionId",
-			id:   &ID{Descriptor: &CollectionId{CollectionID: "1", EnvironmentId: EnvironmentID{EnvironmentID: "1", SpaceID: SpaceID{SpaceID: "1"}}}},
-		},
-		{
-			name: "SchemaID",
-			id:   &ID{Descriptor: &SchemaID{CollectionId: "1", EnvironmentID: EnvironmentID{EnvironmentID: "1", SpaceID: SpaceID{SpaceID: "1"}}}},
-		},
-		{
-			name: "ItemId",
-			id:   &ID{Descriptor: &ItemId{ItemID: "1", CollectionId: CollectionId{CollectionID: "1", EnvironmentId: EnvironmentID{EnvironmentID: "1", SpaceID: SpaceID{SpaceID: "1"}}}}},
-		},
-		{
-			name: "RevisionID",
-			id:   &ID{Descriptor: &RevisionID{RevisionID: "1", ItemId: ItemId{ItemID: "1", CollectionId: CollectionId{CollectionID: "1", EnvironmentId: EnvironmentID{EnvironmentID: "1", SpaceID: SpaceID{SpaceID: "1"}}}}}},
-		},
-		{
-			name: "FieldId",
-			id:   &ID{Descriptor: &FieldId{FieldName: "1", ItemId: ItemId{ItemID: "1", CollectionId: CollectionId{CollectionID: "1", EnvironmentId: EnvironmentID{EnvironmentID: "1", SpaceID: SpaceID{SpaceID: "1"}}}}}},
-		},
-		{
-			name: "SystemID",
-			id:   &ID{Descriptor: &SystemID{}},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			b, err := jsoniter.Marshal(&tt.id)
-			require.NoError(t, err)
-
-			var i ID
-			require.NoError(t, jsoniter.Unmarshal(b, &i))
-			assert.Equal(t, tt.id, &i, "после Unmarshal объект должен быть идентичен исходному")
-		})
-	}
-}
-
-func TestID_ExampleJSON(t *testing.T) {
-	type data struct {
-		ID     *ID
-		Text   string
-		Number int
-	}
-
-	test := &data{
-		ID:     &ID{Descriptor: &SpaceID{SpaceID: Space}},
-		Text:   "text",
-		Number: 1,
-	}
-
-	b, err := jsoniter.Marshal(test)
-	require.NoError(t, err)
-
-	buf := new(data)
-	err = jsoniter.Unmarshal(b, &buf)
-	require.NoError(t, err)
-	assert.Equal(t, test, buf, "после Unmarshal объект должен совпадать с исходным")
-}
diff --git a/id/_space.go b/id/_space.go
deleted file mode 100644
index 4b7bff76aaf59df6ca70aeff78cfd8e95680821a..0000000000000000000000000000000000000000
--- a/id/_space.go
+++ /dev/null
@@ -1,48 +0,0 @@
-package id
-
-const (
-	Space        = "space"
-	SpacesPrefix = "spaces"
-)
-
-type SpaceID struct {
-	SpaceID string `json:"space_id,omitempty" bson:"space_id,omitempty"`
-}
-
-func (t *SpaceID) Type() string { return Space }
-
-func (t *SpaceID) String() string {
-	return Join(SpacesPrefix, t.SpaceID)
-}
-
-func (t *SpaceID) Map() map[string]any {
-	return map[string]any{
-		"space_id": t.SpaceID,
-		"type":     Space,
-	}
-}
-
-func (t *SpaceID) FromMap(m map[string]any) error {
-	t.SpaceID = m["space_id"].(string)
-	return nil
-}
-
-func (t *SpaceID) Validate() error {
-	if t.SpaceID == "" {
-		return ErrInvalidID
-	}
-	return nil
-}
-
-func parseSpaceID(parts []string) (*SpaceID, error) {
-	var id SpaceID
-	if len(parts) != 2 || parts[0] != SpacesPrefix {
-		return nil, ErrInvalidID
-	}
-
-	id.SpaceID = parts[1]
-	return &id, nil
-}
-func NewSpaceID(id string) *ID {
-	return &ID{Descriptor: &SpaceID{SpaceID: id}}
-}
diff --git a/id/bson_test.go b/id/bson_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..7ae62ccba4e1dbc2e74ac48b8c5890216a6cba50
--- /dev/null
+++ b/id/bson_test.go
@@ -0,0 +1,108 @@
+package id
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.mongodb.org/mongo-driver/bson"
+)
+
+func TestID_MarshalUnmarshalBSON(t *testing.T) {
+	tests := []struct {
+		name string
+		id   *ObjectId
+	}{
+		{
+			name: "OrganizationID",
+			id:   &ObjectId{Descriptor: &OrganizationId{OrganizationID: "1"}},
+		},
+		{
+			name: "UserID",
+			id:   &ObjectId{Descriptor: &UserId{UserID: "1"}},
+		},
+		{
+			name: "ServiceID",
+			id:   &ObjectId{Descriptor: &ServiceId{ServiceID: "1"}},
+		},
+		{
+			name: "SpaceId",
+			id:   &ObjectId{Descriptor: &SpaceId{SpaceID: "1"}},
+		},
+		{
+			name: "EnvironmentID",
+			id:   &ObjectId{Descriptor: &EnvironmentId{EnvironmentID: "1", SpaceId: SpaceId{SpaceID: "1"}}},
+		},
+		{
+			name: "ClientID",
+			id:   &ObjectId{Descriptor: &ClientId{ClientID: "1", SpaceId: SpaceId{SpaceID: "1"}}},
+		},
+		{
+			name: "RoleID",
+			id:   &ObjectId{Descriptor: &RoleId{RoleID: "1", SpaceId: SpaceId{SpaceID: "1"}}},
+		},
+		{
+			name: "CollectionId",
+			id:   &ObjectId{Descriptor: &CollectionId{CollectionID: "1", EnvironmentId: EnvironmentId{EnvironmentID: "1", SpaceId: SpaceId{SpaceID: "1"}}}},
+		},
+		{
+			name: "SchemaID",
+			id:   &ObjectId{Descriptor: &SchemaId{CollectionID: "1", EnvironmentId: EnvironmentId{EnvironmentID: "1", SpaceId: SpaceId{SpaceID: "1"}}}},
+		},
+		{
+			name: "ItemId",
+			id:   &ObjectId{Descriptor: &ItemId{ItemID: "1", CollectionId: CollectionId{CollectionID: "1", EnvironmentId: EnvironmentId{EnvironmentID: "1", SpaceId: SpaceId{SpaceID: "1"}}}}},
+		},
+		{
+			name: "RevisionID",
+			id:   &ObjectId{Descriptor: &RevisionId{RevisionID: "1", ItemId: ItemId{ItemID: "1", CollectionId: CollectionId{CollectionID: "1", EnvironmentId: EnvironmentId{EnvironmentID: "1", SpaceId: SpaceId{SpaceID: "1"}}}}}},
+		},
+		{
+			name: "FieldId",
+			id:   &ObjectId{Descriptor: &FieldId{Field: "1", ItemId: ItemId{ItemID: "1", CollectionId: CollectionId{CollectionID: "1", EnvironmentId: EnvironmentId{EnvironmentID: "1", SpaceId: SpaceId{SpaceID: "1"}}}}}},
+		},
+		{
+			name: "SystemID",
+			id:   &ObjectId{Descriptor: &SystemId{}},
+		},
+	}
+	type test struct {
+		Text string
+		ID   *ObjectId
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := &test{Text: tt.name, ID: tt.id}
+
+			b, err := bson.Marshal(s)
+			require.NoError(t, err)
+
+			var v *test
+			require.NoError(t, bson.Unmarshal(b, &v))
+			assert.Equal(t, s, v, "после Unmarshal объект должен быть идентичен исходному")
+		})
+	}
+}
+
+func TestID_ExampleBSON(t *testing.T) {
+	type data struct {
+		ID *ObjectId
+
+		Text   string
+		Number int
+	}
+
+	test := &data{
+		ID:     &ObjectId{Descriptor: &SpaceId{SpaceID: Space}},
+		Text:   "text",
+		Number: 1,
+	}
+
+	b, err := bson.Marshal(test)
+	require.NoError(t, err)
+
+	buf := new(data)
+	err = bson.Unmarshal(b, &buf)
+	require.NoError(t, err)
+	assert.Equal(t, test, buf, "после Unmarshal объект должен совпадать с исходным")
+}
diff --git a/id/client.go b/id/client.go
new file mode 100644
index 0000000000000000000000000000000000000000..d2a8d0bc2edbe0f191bf9396135137441084776a
--- /dev/null
+++ b/id/client.go
@@ -0,0 +1,59 @@
+package id
+
+import "fmt"
+
+const (
+	Client        = "client"
+	ClientsPrefix = "clients"
+)
+
+var _ Descriptor = &ClientId{}
+
+type ClientId struct {
+	SpaceId
+	ClientID string `json:"client_id,omitempty" bson:"client_id,omitempty"`
+}
+
+func (id *ClientId) New() Descriptor {
+	return &ClientId{}
+}
+
+func (id *ClientId) Type() string { return Client }
+
+func (id *ClientId) String() string {
+	return Join(id.SpaceId.String(), ClientsPrefix, id.ClientID)
+}
+
+func (id *ClientId) FromParts(parts []string) error {
+	if len(parts) != 4 || parts[2] != ClientsPrefix {
+		return ErrInvalid
+	}
+	if err := id.SpaceId.FromParts(parts[:2]); err != nil {
+		return err
+	}
+	id.ClientID = parts[3]
+	return nil
+}
+
+func (id *ClientId) Map() map[string]any {
+	m := id.SpaceId.Map()
+	m["client_id"] = id.ClientID
+	m["type"] = Client
+	return m
+}
+
+func (id *ClientId) FromMap(m map[string]any) error {
+	id.ClientID, _ = m["client_id"].(string)
+	if id.ClientID == "" {
+		return fmt.Errorf("%w: ClientID required", ErrInvalid)
+	}
+	return id.SpaceId.FromMap(m)
+}
+
+func (id *ClientId) Validate() error {
+	if id.ClientID == "" {
+		return fmt.Errorf("%w: ClientID required", ErrInvalid)
+	}
+
+	return id.SpaceId.Validate()
+}
diff --git a/id/collection.go b/id/collection.go
index d74aa5f1af352b51926013dbf5a3c152a7ee0dbd..49826e7a83cb5540b55830fdb8074a162ec73b2c 100644
--- a/id/collection.go
+++ b/id/collection.go
@@ -18,15 +18,15 @@ func (id *CollectionId) New() Descriptor {
 	return &CollectionId{}
 }
 
-func (t *CollectionId) Type() string { return Collection }
+func (id *CollectionId) Type() string { return Collection }
 
-func (t *CollectionId) String() string {
-	return Join(t.EnvironmentId.String(), CollectionsPrefix, t.CollectionID)
+func (id *CollectionId) String() string {
+	return Join(id.EnvironmentId.String(), CollectionsPrefix, id.CollectionID)
 }
 
-func (t *CollectionId) Map() map[string]any {
-	m := t.EnvironmentId.Map()
-	m["col_id"] = t.CollectionID
+func (id *CollectionId) Map() map[string]any {
+	m := id.EnvironmentId.Map()
+	m["col_id"] = id.CollectionID
 	m["type"] = Collection
 	return m
 }
@@ -50,9 +50,9 @@ func (id *CollectionId) FromMap(m map[string]any) error {
 	return id.EnvironmentId.FromMap(m)
 }
 
-func (t *CollectionId) Validate() error {
-	if t.CollectionID == "" {
+func (id *CollectionId) Validate() error {
+	if id.CollectionID == "" {
 		return fmt.Errorf("%w: CollectionID required", ErrInvalid)
 	}
-	return t.EnvironmentId.Validate()
+	return id.EnvironmentId.Validate()
 }
diff --git a/id/field.go b/id/field.go
index 11c7e2702bd78809c91bc0e13eb11429b5ffe8b7..0310c9165a420af3b60cab3df32e796e8e6e0894 100644
--- a/id/field.go
+++ b/id/field.go
@@ -12,51 +12,51 @@ type FieldId struct {
 	Field string `json:"field,omitempty" bson:"field,omitempty"`
 }
 
-func (i *FieldId) New() Descriptor {
+func (id *FieldId) New() Descriptor {
 	return &FieldId{}
 }
 
-func (i *FieldId) Type() string { return Field }
+func (id *FieldId) Type() string { return Field }
 
-func (i *FieldId) String() string {
-	return Join(i.ItemId.String(), FieldsPrefix, i.Field)
+func (id *FieldId) String() string {
+	return Join(id.ItemId.String(), FieldsPrefix, id.Field)
 
 }
 
-func (i *FieldId) FromParts(parts []string) error {
+func (id *FieldId) FromParts(parts []string) error {
 	if len(parts) != 10 || parts[8] != FieldsPrefix {
 		return ErrInvalid
 	}
-	if err := i.ItemId.FromParts(parts[:8]); err != nil {
+	if err := id.ItemId.FromParts(parts[:8]); err != nil {
 		return err
 	}
-	i.Field = parts[9]
+	id.Field = parts[9]
 	return nil
 }
 
-func (i *FieldId) Map() map[string]any {
-	m := i.ItemId.Map()
-	m["field"] = i.Field
+func (id *FieldId) Map() map[string]any {
+	m := id.ItemId.Map()
+	m["field"] = id.Field
 	m["type"] = Field
 	return m
 }
 
-func (i *FieldId) FromMap(m map[string]any) error {
-	i.Field = m["field"].(string)
-	if i.Field == "" {
+func (id *FieldId) FromMap(m map[string]any) error {
+	id.Field = m["field"].(string)
+	if id.Field == "" {
 		return fmt.Errorf("%w: Field required", ErrInvalid)
 	}
 
-	if err := i.ItemId.FromMap(m); err != nil {
+	if err := id.ItemId.FromMap(m); err != nil {
 		return err
 	}
 	return nil
 }
 
-func (i *FieldId) Validate() error {
-	if i.Field == "" {
+func (id *FieldId) Validate() error {
+	if id.Field == "" {
 		return fmt.Errorf("%w: Field required", ErrInvalid)
 	}
 
-	return i.ItemId.Validate()
+	return id.ItemId.Validate()
 }
diff --git a/id/json_test.go b/id/json_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..0da4f292db94ffc93558b76ba702f63b0ce5a121
--- /dev/null
+++ b/id/json_test.go
@@ -0,0 +1,101 @@
+package id
+
+import (
+	"testing"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestID_MarshalUnmarshalJSON(t *testing.T) {
+	tests := []struct {
+		name string
+		id   *ObjectId
+	}{
+		{
+			name: "OrganizationID",
+			id:   &ObjectId{Descriptor: &OrganizationId{OrganizationID: "1"}},
+		},
+		{
+			name: "UserID",
+			id:   &ObjectId{Descriptor: &UserId{UserID: "1"}},
+		},
+		{
+			name: "ServiceID",
+			id:   &ObjectId{Descriptor: &ServiceId{ServiceID: "1"}},
+		},
+		{
+			name: "SpaceId",
+			id:   &ObjectId{Descriptor: &SpaceId{SpaceID: "1"}},
+		},
+		{
+			name: "EnvironmentID",
+			id:   &ObjectId{Descriptor: &EnvironmentId{EnvironmentID: "1", SpaceId: SpaceId{SpaceID: "1"}}},
+		},
+		{
+			name: "ClientID",
+			id:   &ObjectId{Descriptor: &ClientId{ClientID: "1", SpaceId: SpaceId{SpaceID: "1"}}},
+		},
+		{
+			name: "RoleID",
+			id:   &ObjectId{Descriptor: &RoleId{RoleID: "1", SpaceId: SpaceId{SpaceID: "1"}}},
+		},
+		{
+			name: "CollectionId",
+			id:   &ObjectId{Descriptor: &CollectionId{CollectionID: "1", EnvironmentId: EnvironmentId{EnvironmentID: "1", SpaceId: SpaceId{SpaceID: "1"}}}},
+		},
+		{
+			name: "SchemaID",
+			id:   &ObjectId{Descriptor: &SchemaId{CollectionID: "1", EnvironmentId: EnvironmentId{EnvironmentID: "1", SpaceId: SpaceId{SpaceID: "1"}}}},
+		},
+		{
+			name: "ItemId",
+			id:   &ObjectId{Descriptor: &ItemId{ItemID: "1", CollectionId: CollectionId{CollectionID: "1", EnvironmentId: EnvironmentId{EnvironmentID: "1", SpaceId: SpaceId{SpaceID: "1"}}}}},
+		},
+		{
+			name: "RevisionID",
+			id:   &ObjectId{Descriptor: &RevisionId{RevisionID: "1", ItemId: ItemId{ItemID: "1", CollectionId: CollectionId{CollectionID: "1", EnvironmentId: EnvironmentId{EnvironmentID: "1", SpaceId: SpaceId{SpaceID: "1"}}}}}},
+		},
+		{
+			name: "FieldId",
+			id:   &ObjectId{Descriptor: &FieldId{Field: "1", ItemId: ItemId{ItemID: "1", CollectionId: CollectionId{CollectionID: "1", EnvironmentId: EnvironmentId{EnvironmentID: "1", SpaceId: SpaceId{SpaceID: "1"}}}}}},
+		},
+		{
+			name: "SystemID",
+			id:   &ObjectId{Descriptor: &SystemId{}},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			b, err := jsoniter.Marshal(&tt.id)
+			require.NoError(t, err)
+
+			var i ObjectId
+			require.NoError(t, jsoniter.Unmarshal(b, &i))
+			assert.Equal(t, tt.id, &i, "после Unmarshal объект должен быть идентичен исходному")
+		})
+	}
+}
+
+func TestID_ExampleJSON(t *testing.T) {
+	type data struct {
+		ID     *ObjectId
+		Text   string
+		Number int
+	}
+
+	test := &data{
+		ID:     &ObjectId{Descriptor: &SpaceId{SpaceID: Space}},
+		Text:   "text",
+		Number: 1,
+	}
+
+	b, err := jsoniter.Marshal(test)
+	require.NoError(t, err)
+
+	buf := new(data)
+	err = jsoniter.Unmarshal(b, &buf)
+	require.NoError(t, err)
+	assert.Equal(t, test, buf, "после Unmarshal объект должен совпадать с исходным")
+}
diff --git a/id/object_id_test.go b/id/object_id_test.go
index b6714573ce59fefa1b29e437aa080a50b5b47308..572f0da96c190a2138875c6b7dcb24c237fbe6fa 100644
--- a/id/object_id_test.go
+++ b/id/object_id_test.go
@@ -3,6 +3,7 @@ package id
 import (
 	"testing"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -18,157 +19,92 @@ func Test_ParseID(t *testing.T) {
 			id:     "/spaces/<space_id>",
 			result: MustObjectId("/spaces/<space_id>"),
 		},
+		{
+			name:   "ServiceID",
+			id:     "/services/<service_id>",
+			result: MustObjectId("/services/<service_id>"),
+		},
+		{
+			name:   "UserID",
+			id:     "/users/<user_id>",
+			result: MustObjectId("/users/<user_id>"),
+		},
+		{
+			name:   "OrganizationID",
+			id:     "/orgs/<org_id>",
+			result: MustObjectId("/orgs/<org_id>"),
+		},
+		{
+			name:   "ClientID",
+			id:     "/spaces/<space_id>/clients/<client_id>",
+			result: MustObjectId("/spaces/<space_id>/clients/<client_id>"),
+		},
+		{
+			name:   "RoleID",
+			id:     "/spaces/<space_id>/roles/<role_id>",
+			result: MustObjectId("/spaces/<space_id>/roles/<role_id>"),
+		},
+		{
+			name:   "EnvironmentID",
+			id:     "/spaces/<space_id>/envs/<env_id>",
+			result: MustObjectId("/spaces/<space_id>/envs/<env_id>"),
+		},
+		{
+			name:   "CollectionId",
+			id:     "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>",
+			result: MustObjectId("/spaces/<space_id>/envs/<env_id>/cols/<collection_id>"),
+		},
+		{
+			name:   "SchemaID",
+			id:     "/spaces/<space_id>/envs/<env_id>/schema/<collection_id>",
+			result: MustObjectId("/spaces/<space_id>/envs/<env_id>/schema/<collection_id>"),
+		},
+		{
+			name:   "ItemId",
+			id:     "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>/items/<item_id>",
+			result: MustObjectId("/spaces/<space_id>/envs/<env_id>/cols/<collection_id>/items/<item_id>"),
+		},
+		{
+			name:   "RevisionID",
+			id:     "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>/items/<item_id>/revs/<rev_id>",
+			result: MustObjectId("/spaces/<space_id>/envs/<env_id>/cols/<collection_id>/items/<item_id>/revs/<rev_id>"),
+		},
+		{
+			name:   "FieldId",
+			id:     "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>/items/<item_id>/fields/<field_name>",
+			result: MustObjectId("/spaces/<space_id>/envs/<env_id>/cols/<collection_id>/items/<item_id>/fields/<field_name>"),
+		},
+		{
+			name:      "With error #1: no backslash in the beginning of id",
+			id:        "spaces/<space_id>",
+			result:    nil,
+			wantError: true,
+		},
+		{
+			name:      "With error #2: backslash in the end of id",
+			id:        "/spaces/<space_id>/",
+			result:    nil,
+			wantError: true,
+		},
+		{
+			name:      "With error #3: typo in 'spaces'",
+			id:        "/space/<space_id>",
+			result:    nil,
+			wantError: true,
+		},
+		{
+			name:      "With error #4: no space_id in id",
+			id:        "/spaces",
+			result:    nil,
+			wantError: true,
+		},
+		{
+			name:      "With error #5: multiple backslashes in the end of id",
+			id:        "/spaces/<space_id>///",
+			result:    nil,
+			wantError: true,
+		},
 	}
-	//{
-	//	name:   "ServiceID",
-	//	id:     "/services/<service_id>",
-	//	result: &ID{Descriptor: &ServiceID{ServiceID: "<service_id>"}},
-	//},
-	//{
-	//	name:   "UserID",
-	//	id:     "/users/<user_id>",
-	//	result: &ID{Descriptor: &UserID{UserID: "<user_id>"}},
-	//},
-	//{
-	//	name:   "OrganizationID",
-	//	id:     "/orgs/<org_id>",
-	//	result: &ID{Descriptor: &OrganizationID{OrganizationID: "<org_id>"}},
-	//},
-	//	{
-	//		name:   "SpaceId",
-	//		id:     "/spaces/<space_id>",
-	//		result: &ID{Descriptor: &SpaceID{SpaceID: "<space_id>"}},
-	//	},
-	//	{
-	//		name: "ClientID",
-	//		id:   "/spaces/<space_id>/clients/<client_id>",
-	//		result: &ID{Descriptor: &ClientID{
-	//			SpaceID:  SpaceID{SpaceID: "<space_id>"},
-	//			ClientID: "<client_id>",
-	//		}},
-	//	},
-	//	{
-	//		name: "RoleID",
-	//		id:   "/spaces/<space_id>/roles/<role_id>",
-	//		result: &ID{Descriptor: &RoleID{
-	//			SpaceID: SpaceID{SpaceID: "<space_id>"},
-	//			RoleID:  "<role_id>",
-	//		}},
-	//	},
-	//	{
-	//		name: "EnvironmentID",
-	//		id:   "/spaces/<space_id>/envs/<env_id>",
-	//		result: &ID{Descriptor: &EnvironmentID{
-	//			SpaceID:       SpaceID{SpaceID: "<space_id>"},
-	//			EnvironmentID: "<env_id>",
-	//		}},
-	//	},
-	//	{
-	//		name: "CollectionId",
-	//		id:   "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>",
-	//		result: &ID{Descriptor: &CollectionId{
-	//			EnvironmentID: EnvironmentID{
-	//				SpaceID:       SpaceID{SpaceID: "<space_id>"},
-	//				EnvironmentID: "<env_id>",
-	//			},
-	//			CollectionId: "<collection_id>",
-	//		}},
-	//	},
-	//	{
-	//		name: "SchemaID",
-	//		id:   "/spaces/<space_id>/envs/<env_id>/schema/<collection_id>",
-	//		result: &ID{Descriptor: &SchemaID{
-	//			EnvironmentID: EnvironmentID{
-	//				SpaceID:       SpaceID{SpaceID: "<space_id>"},
-	//				EnvironmentID: "<env_id>",
-	//			},
-	//			CollectionId: "<collection_id>",
-	//		}},
-	//	},
-	//	{
-	//		name: "ItemId",
-	//		id:   "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>/items/<item_id>",
-	//		result: &ID{Descriptor: &ItemId{
-	//			CollectionId: CollectionId{
-	//				EnvironmentID: EnvironmentID{
-	//					SpaceID:       SpaceID{SpaceID: "<space_id>"},
-	//					EnvironmentID: "<env_id>",
-	//				},
-	//				CollectionId: "<collection_id>",
-	//			},
-	//			ItemId: "<item_id>",
-	//		}},
-	//	},
-	//	{
-	//		name: "RevisionID",
-	//		id:   "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>/items/<item_id>/revs/<rev_id>",
-	//		result: &ID{Descriptor: &RevisionID{
-	//			ItemId: ItemId{
-	//				CollectionId: CollectionId{
-	//					EnvironmentID: EnvironmentID{
-	//						SpaceID:       SpaceID{SpaceID: "<space_id>"},
-	//						EnvironmentID: "<env_id>",
-	//					},
-	//					CollectionId: "<collection_id>",
-	//				},
-	//				ItemId: "<item_id>",
-	//			},
-	//			RevisionID: "<rev_id>",
-	//		}},
-	//	},
-	//	{
-	//		name: "FieldId",
-	//		id:   "/spaces/<space_id>/envs/<env_id>/cols/<collection_id>/items/<item_id>/fields/<field_name>",
-	//		result: &ID{Descriptor: &FieldId{
-	//			ItemId: ItemId{
-	//				CollectionId: CollectionId{
-	//					EnvironmentID: EnvironmentID{
-	//						SpaceID:       SpaceID{SpaceID: "<space_id>"},
-	//						EnvironmentID: "<env_id>",
-	//					},
-	//					CollectionId: "<collection_id>",
-	//				},
-	//				ItemId: "<item_id>",
-	//			},
-	//			FieldName: "<field_name>",
-	//		}},
-	//	},
-	//	{
-	//		name:   "SystemID",
-	//		id:     "/system",
-	//		result: &ID{Descriptor: &SystemID{}},
-	//	},
-	//	{
-	//		name:      "With error #1: no backslash in the beginning of id",
-	//		id:        "spaces/<space_id>",
-	//		result:    nil,
-	//		wantError: true,
-	//	},
-	//	{
-	//		name:      "With error #2: backslash in the end of id",
-	//		id:        "/spaces/<space_id>/",
-	//		result:    nil,
-	//		wantError: true,
-	//	},
-	//	{
-	//		name:      "With error #3: typo in 'spaces'",
-	//		id:        "/space/<space_id>",
-	//		result:    nil,
-	//		wantError: true,
-	//	},
-	//	{
-	//		name:      "With error #4: no space_id in id",
-	//		id:        "/spaces",
-	//		result:    nil,
-	//		wantError: true,
-	//	},
-	//	{
-	//		name:      "With error #5: multiple backslashes in the end of id",
-	//		id:        "/spaces/<space_id>///",
-	//		result:    nil,
-	//		wantError: true,
-	//	},
-	//}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			id, err := NewObjectId(tt.id)
@@ -183,124 +119,124 @@ func Test_ParseID(t *testing.T) {
 	}
 }
 
-//func Test_Map(t *testing.T) {
-//	tests := []struct {
-//		name string
-//		id   *ID
-//	}{
-//		{
-//			name: "ServiceID",
-//			id:   &ID{Descriptor: &ServiceID{ServiceID: "<service_id>"}},
-//		},
-//		{
-//			name: "UserID",
-//			id:   &ID{Descriptor: &UserID{UserID: "<user_id>"}},
-//		},
-//		{
-//			name: "OrganizationID",
-//			id:   &ID{Descriptor: &OrganizationID{OrganizationID: "<org_id>"}},
-//		},
-//		{
-//			name: "SpaceId",
-//			id:   &ID{Descriptor: &SpaceID{SpaceID: "<space_id>"}},
-//		},
-//		{
-//			name: "ClientID",
-//			id: &ID{Descriptor: &ClientID{
-//				SpaceID:  SpaceID{SpaceID: "<space_id>"},
-//				ClientID: "<client_id>",
-//			}},
-//		},
-//		{
-//			name: "RoleID",
-//			id: &ID{Descriptor: &RoleID{
-//				SpaceID: SpaceID{SpaceID: "<space_id>"},
-//				RoleID:  "<role_id>",
-//			}},
-//		},
-//		{
-//			name: "EnvironmentID",
-//			id: &ID{Descriptor: &EnvironmentID{
-//				SpaceID:       SpaceID{SpaceID: "<space_id>"},
-//				EnvironmentID: "<env_id>",
-//			}},
-//		},
-//		{
-//			name: "CollectionId",
-//			id: &ID{Descriptor: &CollectionId{
-//				EnvironmentId: EnvironmentID{
-//					SpaceID:       SpaceID{SpaceID: "<space_id>"},
-//					EnvironmentID: "<env_id>",
-//				},
-//				CollectionID: "<collection_id>",
-//			}},
-//		},
-//		{
-//			name: "Schema ID",
-//			id: &ID{Descriptor: &SchemaID{
-//				EnvironmentID: EnvironmentID{
-//					SpaceID:       SpaceID{SpaceID: "<space_id>"},
-//					EnvironmentID: "<env_id>",
-//				},
-//				CollectionId: "<collection_id>",
-//			}},
-//		},
-//		{
-//			name: "ItemId",
-//			id: &ID{Descriptor: &ItemId{
-//				CollectionId: CollectionId{
-//					EnvironmentId: EnvironmentID{
-//						SpaceID:       SpaceID{SpaceID: "<space_id>"},
-//						EnvironmentID: "<env_id>",
-//					},
-//					CollectionID: "<collection_id>",
-//				},
-//				ItemID: "<item_id>",
-//			}},
-//		},
-//		{
-//			name: "RevisionID",
-//			id: &ID{Descriptor: &RevisionID{
-//				ItemId: ItemId{
-//					CollectionId: CollectionId{
-//						EnvironmentId: EnvironmentID{
-//							SpaceID:       SpaceID{SpaceID: "<space_id>"},
-//							EnvironmentID: "<env_id>",
-//						},
-//						CollectionID: "<collection_id>",
-//					},
-//					ItemID: "<item_id>",
-//				},
-//				RevisionID: "<rev_id>",
-//			}},
-//		},
-//		{
-//			name: "FieldId",
-//			id: &ID{Descriptor: &FieldId{
-//				ItemId: ItemId{
-//					CollectionId: CollectionId{
-//						EnvironmentId: EnvironmentID{
-//							SpaceID:       SpaceID{SpaceID: "<space_id>"},
-//							EnvironmentID: "<env_id>",
-//						},
-//						CollectionID: "<collection_id>",
-//					},
-//					ItemID: "<item_id>",
-//				},
-//				FieldName: "<field_name>",
-//			}},
-//		},
-//		{
-//			name: "SystemID",
-//			id:   &ID{Descriptor: &SystemID{}},
-//		},
-//	}
-//	for _, tt := range tests {
-//		t.Run(tt.name, func(t *testing.T) {
-//			v, err := FromMap(tt.id.Map())
-//			require.NoError(t, err)
-//			assert.Equal(t, tt.id, v, "проверка FromMap для типа ID, должен быть равен исходному значению")
-//			assert.Equal(t, v.Map(), tt.id.Map())
-//		})
-//	}
-//}
+func Test_Map(t *testing.T) {
+	tests := []struct {
+		name string
+		id   *ObjectId
+	}{
+		{
+			name: "ServiceID",
+			id:   &ObjectId{Descriptor: &ServiceId{ServiceID: "<service_id>"}},
+		},
+		{
+			name: "UserID",
+			id:   &ObjectId{Descriptor: &UserId{UserID: "<user_id>"}},
+		},
+		{
+			name: "OrganizationID",
+			id:   &ObjectId{Descriptor: &OrganizationId{OrganizationID: "<org_id>"}},
+		},
+		{
+			name: "SpaceId",
+			id:   &ObjectId{Descriptor: &SpaceId{SpaceID: "<space_id>"}},
+		},
+		{
+			name: "ClientID",
+			id: &ObjectId{Descriptor: &ClientId{
+				SpaceId:  SpaceId{SpaceID: "<space_id>"},
+				ClientID: "<client_id>",
+			}},
+		},
+		{
+			name: "RoleID",
+			id: &ObjectId{Descriptor: &RoleId{
+				SpaceId: SpaceId{SpaceID: "<space_id>"},
+				RoleID:  "<role_id>",
+			}},
+		},
+		{
+			name: "EnvironmentID",
+			id: &ObjectId{Descriptor: &EnvironmentId{
+				SpaceId:       SpaceId{SpaceID: "<space_id>"},
+				EnvironmentID: "<env_id>",
+			}},
+		},
+		{
+			name: "CollectionId",
+			id: &ObjectId{Descriptor: &CollectionId{
+				EnvironmentId: EnvironmentId{
+					SpaceId:       SpaceId{SpaceID: "<space_id>"},
+					EnvironmentID: "<env_id>",
+				},
+				CollectionID: "<collection_id>",
+			}},
+		},
+		{
+			name: "Schema ID",
+			id: &ObjectId{Descriptor: &SchemaId{
+				EnvironmentId: EnvironmentId{
+					SpaceId:       SpaceId{SpaceID: "<space_id>"},
+					EnvironmentID: "<env_id>",
+				},
+				CollectionID: "<collection_id>",
+			}},
+		},
+		{
+			name: "ItemId",
+			id: &ObjectId{Descriptor: &ItemId{
+				CollectionId: CollectionId{
+					EnvironmentId: EnvironmentId{
+						SpaceId:       SpaceId{SpaceID: "<space_id>"},
+						EnvironmentID: "<env_id>",
+					},
+					CollectionID: "<collection_id>",
+				},
+				ItemID: "<item_id>",
+			}},
+		},
+		{
+			name: "RevisionID",
+			id: &ObjectId{Descriptor: &RevisionId{
+				ItemId: ItemId{
+					CollectionId: CollectionId{
+						EnvironmentId: EnvironmentId{
+							SpaceId:       SpaceId{SpaceID: "<space_id>"},
+							EnvironmentID: "<env_id>",
+						},
+						CollectionID: "<collection_id>",
+					},
+					ItemID: "<item_id>",
+				},
+				RevisionID: "<rev_id>",
+			}},
+		},
+		{
+			name: "FieldId",
+			id: &ObjectId{Descriptor: &FieldId{
+				ItemId: ItemId{
+					CollectionId: CollectionId{
+						EnvironmentId: EnvironmentId{
+							SpaceId:       SpaceId{SpaceID: "<space_id>"},
+							EnvironmentID: "<env_id>",
+						},
+						CollectionID: "<collection_id>",
+					},
+					ItemID: "<item_id>",
+				},
+				Field: "<field_name>",
+			}},
+		},
+		{
+			name: "SystemID",
+			id:   &ObjectId{Descriptor: &SystemId{}},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			v, err := FromMap(tt.id.Map())
+			require.NoError(t, err)
+			assert.Equal(t, tt.id, v, "проверка FromMap для типа ID, должен быть равен исходному значению")
+			assert.Equal(t, v.Map(), tt.id.Map())
+		})
+	}
+}
diff --git a/id/old/client.go b/id/old/client.go
deleted file mode 100644
index a329ad67320adc56d749844607f893404024f150..0000000000000000000000000000000000000000
--- a/id/old/client.go
+++ /dev/null
@@ -1,61 +0,0 @@
-package old
-
-const (
-	Client        = "client"
-	ClientsPrefix = "clients"
-)
-
-type ClientID struct {
-	SpaceID
-	ClientID string `json:"client_id,omitempty" bson:"client_id,omitempty"`
-}
-
-func (t *ClientID) Type() string { return Client }
-
-func (t *ClientID) String() string {
-	return Join(t.SpaceID.String(), ClientsPrefix, t.ClientID)
-
-}
-
-func (t *ClientID) Map() map[string]any {
-	m := t.SpaceID.Map()
-	m["client_id"] = t.ClientID
-	m["type"] = Client
-	return m
-}
-
-func (t *ClientID) FromMap(m map[string]any) error {
-	if err := t.SpaceID.FromMap(m); err != nil {
-		return err
-	}
-	t.ClientID = m["client_id"].(string)
-	return nil
-}
-
-func (t *ClientID) Validate() error {
-	if t.ClientID == "" {
-		return ErrInvalidID
-	}
-
-	return t.SpaceID.Validate()
-}
-
-func parseClientID(parts []string) (*ClientID, error) {
-	if len(parts) != 4 || parts[2] != ClientsPrefix {
-		return nil, ErrInvalidID
-	}
-
-	spaceID, err := parseSpaceID(parts[:2])
-	if err != nil {
-		return nil, err
-	}
-
-	var id ClientID
-	id.SpaceID = *spaceID
-	id.ClientID = parts[3]
-	return &id, nil
-}
-
-func NewClientID(spaceID, id string) *ID {
-	return &ID{Descriptor: &ClientID{SpaceID: SpaceID{SpaceID: spaceID}, ClientID: id}}
-}
diff --git a/id/old/organization.go b/id/old/organization.go
deleted file mode 100644
index 2790d8599c7591dcbcc3dbd1ced0ded6ef9e5e5f..0000000000000000000000000000000000000000
--- a/id/old/organization.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package old
-
-const (
-	Organization        = "organization"
-	OrganizationsPrefix = "orgs"
-)
-
-type OrganizationID struct {
-	OrganizationID string `json:"organization_id,omitempty" bson:"organization_id,omitempty"`
-}
-
-func (t *OrganizationID) Type() string { return Organization }
-
-func (t *OrganizationID) String() string {
-	return Join(OrganizationsPrefix, t.OrganizationID)
-}
-
-func (t *OrganizationID) Map() map[string]any {
-	return map[string]any{
-		"organization_id": t.OrganizationID,
-		"type":            Organization,
-	}
-}
-
-func (t *OrganizationID) FromMap(m map[string]any) error {
-	t.OrganizationID = m["organization_id"].(string)
-	return nil
-}
-
-func (t *OrganizationID) Validate() error {
-	if t.OrganizationID == "" {
-		return ErrInvalidID
-	}
-	return nil
-}
-
-func parseOrganizationID(parts []string) (*OrganizationID, error) {
-	var id OrganizationID
-	if len(parts) != 2 || parts[0] != OrganizationsPrefix {
-		return nil, ErrInvalidID
-	}
-
-	id.OrganizationID = parts[1]
-	return &id, nil
-}
-
-func NewOrganizationID(id string) *ID {
-	return &ID{Descriptor: &OrganizationID{OrganizationID: id}}
-}
diff --git a/id/old/revision.go b/id/old/revision.go
deleted file mode 100644
index 143eef649ddc4dcded406d884abb747108c32caa..0000000000000000000000000000000000000000
--- a/id/old/revision.go
+++ /dev/null
@@ -1,61 +0,0 @@
-package old
-
-const (
-	Revision        = "revision"
-	RevisionsPrefix = "revs"
-)
-
-type RevisionID struct {
-	ItemID
-	RevisionID string `json:"rev_id" bson:"rev_id,omitempty"`
-}
-
-func (t *RevisionID) Type() string { return Revision }
-
-func (t *RevisionID) String() string {
-	return Join(t.ItemID.String(), RevisionsPrefix, t.RevisionID)
-
-}
-
-func (t *RevisionID) Map() map[string]any {
-	m := t.ItemID.Map()
-	m["rev_id"] = t.RevisionID
-	m["type"] = Revision
-	return m
-}
-
-func (t *RevisionID) FromMap(m map[string]any) error {
-	if err := t.ItemID.FromMap(m); err != nil {
-		return err
-	}
-	t.RevisionID = m["rev_id"].(string)
-	return nil
-}
-
-func (t *RevisionID) Validate() error {
-	if t.RevisionID == "" {
-		return ErrInvalidID
-	}
-
-	return t.ItemID.Validate()
-}
-
-func parseRevisionID(parts []string) (*RevisionID, error) {
-	if len(parts) != 10 || parts[8] != RevisionsPrefix {
-		return nil, ErrInvalidID
-	}
-
-	itemID, err := parseItemID(parts[:8])
-	if err != nil {
-		return nil, err
-	}
-
-	var id RevisionID
-	id.ItemID = *itemID
-	id.RevisionID = parts[9]
-	return &id, nil
-}
-
-func NewRevisionID(spaceID, envID, collID, itemID, id string) *ID {
-	return &ID{Descriptor: &RevisionID{ItemID: ItemID{CollectionID: CollectionID{EnvironmentID: EnvironmentID{SpaceID: SpaceID{SpaceID: spaceID}, EnvironmentID: envID}, CollectionID: collID}, ItemID: itemID}, RevisionID: id}}
-}
diff --git a/id/old/role.go b/id/old/role.go
deleted file mode 100644
index 6e5d10c99c0329759eb7bec4ab1b06850ad96ca3..0000000000000000000000000000000000000000
--- a/id/old/role.go
+++ /dev/null
@@ -1,61 +0,0 @@
-package old
-
-const (
-	Role        = "role"
-	RolesPrefix = "roles"
-)
-
-type RoleID struct {
-	SpaceID
-	RoleID string `json:"role_id,omitempty" bson:"role_id,omitempty"`
-}
-
-func (t *RoleID) Type() string { return Role }
-
-func (t *RoleID) String() string {
-	return Join(t.SpaceID.String(), RolesPrefix, t.RoleID)
-
-}
-
-func (t *RoleID) Map() map[string]any {
-	m := t.SpaceID.Map()
-	m["role_id"] = t.RoleID
-	m["type"] = Role
-	return m
-}
-
-func (t *RoleID) FromMap(m map[string]any) error {
-	if err := t.SpaceID.FromMap(m); err != nil {
-		return err
-	}
-	t.RoleID = m["role_id"].(string)
-	return nil
-}
-
-func (t *RoleID) Validate() error {
-	if t.RoleID == "" {
-		return ErrInvalidID
-	}
-
-	return t.SpaceID.Validate()
-}
-
-func parseRoleID(parts []string) (*RoleID, error) {
-	if len(parts) != 4 || parts[2] != RolesPrefix {
-		return nil, ErrInvalidID
-	}
-
-	spaceID, err := parseSpaceID(parts[:2])
-	if err != nil {
-		return nil, err
-	}
-
-	var id RoleID
-	id.SpaceID = *spaceID
-	id.RoleID = parts[3]
-	return &id, nil
-}
-
-func NewRoleID(spaceID, id string) *ID {
-	return &ID{Descriptor: &RoleID{SpaceID: SpaceID{SpaceID: spaceID}, RoleID: id}}
-}
diff --git a/id/old/schema.go b/id/old/schema.go
deleted file mode 100644
index 6d02e1c1b7a0fd9d2c7ebe03e7bfc6de42501775..0000000000000000000000000000000000000000
--- a/id/old/schema.go
+++ /dev/null
@@ -1,60 +0,0 @@
-package old
-
-const (
-	Schema       = "schema"
-	SchemaPrefix = "schema"
-)
-
-type SchemaID struct {
-	EnvironmentID
-	CollectionID string `json:"col_id" bson:"col_id,omitempty"`
-}
-
-func (t *SchemaID) Type() string { return Schema }
-
-func (t *SchemaID) String() string {
-	return Join(t.EnvironmentID.String(), SchemaPrefix, t.CollectionID)
-}
-
-func (t *SchemaID) Map() map[string]any {
-	m := t.EnvironmentID.Map()
-	m["col_id"] = t.CollectionID
-	m["type"] = Schema
-	return m
-}
-
-func (t *SchemaID) FromMap(m map[string]any) error {
-	if err := t.EnvironmentID.FromMap(m); err != nil {
-		return err
-	}
-	t.CollectionID = m["col_id"].(string)
-	return nil
-}
-
-func (t *SchemaID) Validate() error {
-	if t.CollectionID == "" {
-		return ErrInvalidID
-	}
-
-	return t.EnvironmentID.Validate()
-}
-
-func parseSchemaID(parts []string) (*SchemaID, error) {
-	if len(parts) != 6 || parts[4] != SchemaPrefix {
-		return nil, ErrInvalidID
-	}
-
-	envID, err := parseEnvironmentID(parts[:4])
-	if err != nil {
-		return nil, err
-	}
-
-	var id SchemaID
-	id.EnvironmentID = *envID
-	id.CollectionID = parts[5]
-	return &id, nil
-}
-
-func NewSchemaID(spaceID, envID, id string) *ID {
-	return &ID{Descriptor: &SchemaID{EnvironmentID: EnvironmentID{SpaceID: SpaceID{SpaceID: spaceID}, EnvironmentID: envID}, CollectionID: id}}
-}
diff --git a/id/old/service.go b/id/old/service.go
deleted file mode 100644
index 5281a974e6e7adfbef4549bb56dafcc0d4e0cfa0..0000000000000000000000000000000000000000
--- a/id/old/service.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package old
-
-const (
-	Service        = "service"
-	ServicesPrefix = "services"
-)
-
-type ServiceID struct {
-	ServiceID string `json:"service_id,omitempty" bson:"service_id,omitempty"`
-}
-
-func (t *ServiceID) Type() string { return Service }
-
-func (t *ServiceID) String() string {
-	return Join(ServicesPrefix, t.ServiceID)
-}
-
-func (t *ServiceID) Map() map[string]any {
-	return map[string]any{
-		"service_id": t.ServiceID,
-		"type":       Service,
-	}
-}
-
-func (t *ServiceID) FromMap(m map[string]any) error {
-	t.ServiceID = m["service_id"].(string)
-	return nil
-}
-
-func (t *ServiceID) Validate() error {
-	if t.ServiceID == "" {
-		return ErrInvalidID
-	}
-	return nil
-}
-
-func parseServiceID(parts []string) (*ServiceID, error) {
-	var id ServiceID
-	if len(parts) != 2 || parts[0] != ServicesPrefix {
-		return nil, ErrInvalidID
-	}
-
-	id.ServiceID = parts[1]
-	return &id, nil
-}
-
-func NewServiceID(id string) *ID {
-	return &ID{Descriptor: &ServiceID{ServiceID: id}}
-}
diff --git a/id/old/system.go b/id/old/system.go
deleted file mode 100644
index 90d15622960302389b313217fc969876529e8df8..0000000000000000000000000000000000000000
--- a/id/old/system.go
+++ /dev/null
@@ -1,22 +0,0 @@
-package old
-
-const System = "system"
-
-type SystemID struct{}
-
-func (t *SystemID) Type() string                   { return Space }
-func (t *SystemID) String() string                 { return string(Separator) + System }
-func (t *SystemID) Map() map[string]any            { return map[string]any{"type": System} }
-func (t *SystemID) FromMap(m map[string]any) error { return nil }
-func (t *SystemID) Validate() error                { return nil }
-
-func parseSystemID(parts []string) (*SystemID, error) {
-	var id SystemID
-	if len(parts) != 1 || parts[0] != System {
-		return nil, ErrInvalidID
-	}
-	return &id, nil
-}
-func NewSystemID() *ID {
-	return &ID{Descriptor: &SystemID{}}
-}
diff --git a/id/old/user.go b/id/old/user.go
deleted file mode 100644
index b4b41147519d7f62d0d7a57511f24a02144f5f81..0000000000000000000000000000000000000000
--- a/id/old/user.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package old
-
-const (
-	User        = "user"
-	UsersPrefix = "users"
-)
-
-type UserID struct {
-	UserID string `json:"user_id,omitempty" bson:"user_id,omitempty"`
-}
-
-func (t *UserID) Type() string { return User }
-
-func (t *UserID) String() string {
-	return Join(UsersPrefix, t.UserID)
-}
-
-func (t *UserID) Map() map[string]any {
-	return map[string]any{
-		"user_id": t.UserID,
-		"type":    User,
-	}
-}
-
-func (t *UserID) FromMap(m map[string]any) error {
-	t.UserID = m["user_id"].(string)
-	return nil
-}
-
-func (t *UserID) Validate() error {
-	if t.UserID == "" {
-		return ErrInvalidID
-	}
-	return nil
-}
-
-func parseUserID(parts []string) (*UserID, error) {
-	var id UserID
-	if len(parts) != 2 || parts[0] != UsersPrefix {
-		return nil, ErrInvalidID
-	}
-
-	id.UserID = parts[1]
-	return &id, nil
-}
-
-func NewUserID(id string) *ID {
-	return &ID{Descriptor: &UserID{UserID: id}}
-}
diff --git a/id/organization.go b/id/organization.go
new file mode 100644
index 0000000000000000000000000000000000000000..7f03bb98233eae72b7a3c296d3de687d5455a0e5
--- /dev/null
+++ b/id/organization.go
@@ -0,0 +1,54 @@
+package id
+
+import "fmt"
+
+const (
+	Organization        = "organization"
+	OrganizationsPrefix = "orgs"
+)
+
+var _ Descriptor = &OrganizationId{}
+
+type OrganizationId struct {
+	OrganizationID string `json:"organization_id,omitempty" bson:"organization_id,omitempty"`
+}
+
+func (id *OrganizationId) New() Descriptor {
+	return &OrganizationId{}
+}
+
+func (id *OrganizationId) Type() string { return Organization }
+
+func (id *OrganizationId) String() string {
+	return Join(OrganizationsPrefix, id.OrganizationID)
+}
+
+func (id *OrganizationId) FromParts(parts []string) error {
+	if len(parts) != 2 || parts[0] != OrganizationsPrefix {
+		return ErrInvalid
+	}
+	id.OrganizationID = parts[1]
+	return nil
+}
+
+func (id *OrganizationId) Map() map[string]any {
+	return map[string]any{
+		"organization_id": id.OrganizationID,
+		"type":            id.Type(),
+	}
+}
+
+func (id *OrganizationId) FromMap(m map[string]any) error {
+	id.OrganizationID, _ = m["organization_id"].(string)
+	if id.OrganizationID == "" {
+		return fmt.Errorf("%w: OrganizationId required", ErrInvalid)
+	}
+	return nil
+}
+
+func (id *OrganizationId) Validate() error {
+	if id.OrganizationID == "" {
+		return fmt.Errorf("%w: OrganizationId required", ErrInvalid)
+	}
+	return nil
+}
diff --git a/id/registry.go b/id/registry.go
index 2a55da002734046d31d48ca06631fa7542fbc544..7d12fe2f28af31a357ba6dea98273b7154b63016 100644
--- a/id/registry.go
+++ b/id/registry.go
@@ -57,7 +57,7 @@ func (r *Registry) FromMap(m map[string]interface{}) (*ObjectId, error) {
 		return &ObjectId{Descriptor: id}, nil
 	}
 
-	return nil, fmt.Errorf("%w: %s", t, ErrInvalid)
+	return nil, fmt.Errorf("%s: %s", t, ErrInvalid)
 }
 
 func (r *Registry) FromObject(v interface{}) (*ObjectId, error) {
@@ -95,8 +95,16 @@ func RegisterSystemIds(r *Registry) {
 	r.RegisterDescriptor(&SpaceId{})
 	r.RegisterDescriptor(&EnvironmentId{})
 	r.RegisterDescriptor(&CollectionId{})
+	r.RegisterDescriptor(&SchemaId{})
 	r.RegisterDescriptor(&ItemId{})
+	r.RegisterDescriptor(&RevisionId{})
 	r.RegisterDescriptor(&FieldId{})
+	r.RegisterDescriptor(&ClientId{})
+	r.RegisterDescriptor(&RoleId{})
+	r.RegisterDescriptor(&UserId{})
+	r.RegisterDescriptor(&SystemId{})
+	r.RegisterDescriptor(&ServiceId{})
+	r.RegisterDescriptor(&OrganizationId{})
 }
 
 func GetRegistry() *Registry {
diff --git a/id/revision.go b/id/revision.go
new file mode 100644
index 0000000000000000000000000000000000000000..6d6c369fd78af30d228603f95dd77fada46a967b
--- /dev/null
+++ b/id/revision.go
@@ -0,0 +1,62 @@
+package id
+
+import "fmt"
+
+const (
+	Revision        = "revision"
+	RevisionsPrefix = "revs"
+)
+
+type RevisionId struct {
+	ItemId
+	RevisionID string `json:"rev_id" bson:"rev_id,omitempty"`
+}
+
+func (id *RevisionId) New() Descriptor {
+	return &RevisionId{}
+}
+
+func (id *RevisionId) Type() string { return Revision }
+
+func (id *RevisionId) String() string {
+	return Join(id.ItemId.String(), RevisionsPrefix, id.RevisionID)
+
+}
+
+func (id *RevisionId) FromParts(parts []string) error {
+	if len(parts) != 10 || parts[8] != RevisionsPrefix {
+		return ErrInvalid
+	}
+	if err := id.ItemId.FromParts(parts[:8]); err != nil {
+		return err
+	}
+	id.RevisionID = parts[9]
+	return nil
+}
+
+func (id *RevisionId) Map() map[string]any {
+	m := id.ItemId.Map()
+	m["rev_id"] = id.RevisionID
+	m["type"] = Revision
+	return m
+}
+
+func (id *RevisionId) FromMap(m map[string]any) error {
+	id.RevisionID = m["rev_id"].(string)
+	if id.RevisionID == "" {
+		return fmt.Errorf("%w: RevisionId required", ErrInvalid)
+	}
+
+	if err := id.ItemId.FromMap(m); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (id *RevisionId) Validate() error {
+	if id.RevisionID == "" {
+		return fmt.Errorf("%w: RevisionId required", ErrInvalid)
+	}
+
+	return id.ItemId.Validate()
+}
diff --git a/id/role.go b/id/role.go
new file mode 100644
index 0000000000000000000000000000000000000000..6644aea412de16bcc3dd1fb5d22a0e70958e402e
--- /dev/null
+++ b/id/role.go
@@ -0,0 +1,59 @@
+package id
+
+import "fmt"
+
+const (
+	Role        = "role"
+	RolesPrefix = "roles"
+)
+
+var _ Descriptor = &RoleId{}
+
+type RoleId struct {
+	SpaceId
+	RoleID string `json:"role_id,omitempty" bson:"role_id,omitempty"`
+}
+
+func (id *RoleId) New() Descriptor {
+	return &RoleId{}
+}
+
+func (id *RoleId) Type() string { return Role }
+
+func (id *RoleId) String() string {
+	return Join(id.SpaceId.String(), RolesPrefix, id.RoleID)
+}
+
+func (id *RoleId) FromParts(parts []string) error {
+	if len(parts) != 4 || parts[2] != RolesPrefix {
+		return ErrInvalid
+	}
+	if err := id.SpaceId.FromParts(parts[:2]); err != nil {
+		return err
+	}
+	id.RoleID = parts[3]
+	return nil
+}
+
+func (id *RoleId) Map() map[string]any {
+	m := id.SpaceId.Map()
+	m["role_id"] = id.RoleID
+	m["type"] = Role
+	return m
+}
+
+func (id *RoleId) FromMap(m map[string]any) error {
+	id.RoleID = m["role_id"].(string)
+	if id.RoleID == "" {
+		return fmt.Errorf("%w: RoleID required", ErrInvalid)
+	}
+	return id.SpaceId.FromMap(m)
+}
+
+func (id *RoleId) Validate() error {
+	if id.RoleID == "" {
+		return fmt.Errorf("%w: RoleID required", ErrInvalid)
+	}
+
+	return id.SpaceId.Validate()
+}
diff --git a/id/schema.go b/id/schema.go
new file mode 100644
index 0000000000000000000000000000000000000000..ad59a14b55fe978a34c627e4a86ee0f14788873f
--- /dev/null
+++ b/id/schema.go
@@ -0,0 +1,56 @@
+package id
+
+import "fmt"
+
+const (
+	Schema       = "schema"
+	SchemaPrefix = "schema"
+)
+
+type SchemaId struct {
+	EnvironmentId
+	CollectionID string `json:"col_id" bson:"col_id,omitempty"`
+}
+
+func (id *SchemaId) New() Descriptor {
+	return &SchemaId{}
+}
+
+func (id *SchemaId) Type() string { return Schema }
+
+func (id *SchemaId) String() string {
+	return Join(id.EnvironmentId.String(), SchemaPrefix, id.CollectionID)
+}
+
+func (id *SchemaId) Map() map[string]any {
+	m := id.EnvironmentId.Map()
+	m["col_id"] = id.CollectionID
+	m["type"] = Schema
+	return m
+}
+
+func (id *SchemaId) FromParts(parts []string) error {
+	if len(parts) != 6 || parts[4] != SchemaPrefix {
+		return ErrInvalid
+	}
+	if err := id.EnvironmentId.FromParts(parts[:4]); err != nil {
+		return err
+	}
+	id.CollectionID = parts[5]
+	return nil
+}
+
+func (id *SchemaId) FromMap(m map[string]any) error {
+	id.CollectionID, _ = m["col_id"].(string)
+	if id.CollectionID == "" {
+		return fmt.Errorf("%w: SchemaID required", ErrInvalid)
+	}
+	return id.EnvironmentId.FromMap(m)
+}
+
+func (id *SchemaId) Validate() error {
+	if id.CollectionID == "" {
+		return fmt.Errorf("%w: SchemaID required", ErrInvalid)
+	}
+	return id.EnvironmentId.Validate()
+}
diff --git a/id/service.go b/id/service.go
new file mode 100644
index 0000000000000000000000000000000000000000..08dba5392de6da2cc1309a93c5a49ffe678e4e4e
--- /dev/null
+++ b/id/service.go
@@ -0,0 +1,54 @@
+package id
+
+import "fmt"
+
+const (
+	Service        = "service"
+	ServicesPrefix = "services"
+)
+
+type ServiceId struct {
+	ServiceID string `json:"service_id,omitempty" bson:"service_id,omitempty"`
+}
+
+var _ Descriptor = &ServiceId{}
+
+func (id *ServiceId) New() Descriptor {
+	return &ServiceId{}
+}
+
+func (id *ServiceId) Type() string { return Service }
+
+func (id *ServiceId) String() string {
+	return Join(ServicesPrefix, id.ServiceID)
+}
+
+func (id *ServiceId) FromParts(parts []string) error {
+	if len(parts) != 2 || parts[0] != ServicesPrefix {
+		return ErrInvalid
+	}
+	id.ServiceID = parts[1]
+	return nil
+}
+
+func (id *ServiceId) Map() map[string]any {
+	return map[string]any{
+		"service_id": id.ServiceID,
+		"type":       id.Type(),
+	}
+}
+
+func (id *ServiceId) FromMap(m map[string]any) error {
+	id.ServiceID, _ = m["service_id"].(string)
+	if id.ServiceID == "" {
+		return fmt.Errorf("%w: ServiceId required", ErrInvalid)
+	}
+	return nil
+}
+
+func (id *ServiceId) Validate() error {
+	if id.ServiceID == "" {
+		return fmt.Errorf("%w: ServiceId required", ErrInvalid)
+	}
+	return nil
+}
diff --git a/id/system.go b/id/system.go
new file mode 100644
index 0000000000000000000000000000000000000000..3efa4b9c927f9861b1cf8e4bc199611eb0dd006b
--- /dev/null
+++ b/id/system.go
@@ -0,0 +1,21 @@
+package id
+
+const System = "system"
+
+type SystemId struct{}
+
+func (id *SystemId) New() Descriptor {
+	return &SystemId{}
+}
+
+func (id *SystemId) Type() string   { return System }
+func (id *SystemId) String() string { return string(Separator) + System }
+func (id *SystemId) FromParts(parts []string) error {
+	if len(parts) != 1 || parts[0] != System {
+		return ErrInvalid
+	}
+	return nil
+}
+func (id *SystemId) Map() map[string]any            { return map[string]any{"type": System} }
+func (id *SystemId) FromMap(m map[string]any) error { return nil }
+func (id *SystemId) Validate() error                { return nil }
diff --git a/id/system/system.go b/id/system/system.go
index 6bd72608bb55aaa412847bdf95458dc5e2394f0f..713fca341268bdda5fcbc6eb553741913be67af3 100644
--- a/id/system/system.go
+++ b/id/system/system.go
@@ -1,14 +1,18 @@
 package system
 
 import (
+	"context"
+	"reflect"
+
 	"git.perx.ru/perxis/perxis-go/id"
 	"git.perx.ru/perxis/perxis-go/pkg/auth"
 	"git.perx.ru/perxis/perxis-go/pkg/collections"
 	"git.perx.ru/perxis/perxis-go/pkg/environments"
 	"git.perx.ru/perxis/perxis-go/pkg/items"
+	"git.perx.ru/perxis/perxis-go/pkg/organizations"
+	"git.perx.ru/perxis/perxis-go/pkg/roles"
 	"git.perx.ru/perxis/perxis-go/pkg/spaces"
 	"git.perx.ru/perxis/perxis-go/pkg/users"
-	"reflect"
 )
 
 func Handler(obj any) *id.ObjectId {
@@ -36,31 +40,50 @@ func Handler(obj any) *id.ObjectId {
 		i.ItemID = val.ID
 		return id.MustObjectId(&i)
 	case *users.User:
-		// TODO
-		break
+		var i id.UserId
+		i.UserID = val.ID
+		return id.MustObjectId(&i)
+	case *organizations.Organization:
+		var i id.OrganizationId
+		i.OrganizationID = val.ID
+		return id.MustObjectId(&i)
+	case *roles.Role:
+		var i id.RoleId
+		i.SpaceID = val.SpaceID
+		i.RoleID = val.ID
+		return id.MustObjectId(&i)
 	case *auth.UserPrincipal:
-		// TODO: Вернуть UserID
-		break
+		var i id.UserId
+		i.UserID = val.GetID(context.TODO())
+		return id.MustObjectId(&i)
 	case *auth.ClientPrincipal:
-		// TODO
-		break
+		var i id.ClientId
+		i.ClientID = val.GetID(context.TODO())
+		return id.MustObjectId(&i)
 	case *auth.SystemPrincipal:
-		// TODO
-		break
+		return id.MustObjectId(&id.SystemId{})
 	case *auth.Anonymous:
-		// TODO
-		break
+		var i id.UserId
+		i.UserID = val.GetID(context.TODO())
+		return id.MustObjectId(&i)
 	}
 	return nil
 }
 
 // Register registers object handler for system types into the provided Registry.
 func Register(r *id.Registry) {
+	r.RegisterObjectHandler(reflect.TypeOf(&organizations.Organization{}), Handler)
 	r.RegisterObjectHandler(reflect.TypeOf(&spaces.Space{}), Handler)
 	r.RegisterObjectHandler(reflect.TypeOf(&environments.Environment{}), Handler)
 	r.RegisterObjectHandler(reflect.TypeOf(&collections.Collection{}), Handler)
 	r.RegisterObjectHandler(reflect.TypeOf(&items.Item{}), Handler)
-	// TODO: Добавить регистрацию для всех системных типов
+	r.RegisterObjectHandler(reflect.TypeOf(&roles.Role{}), Handler)
+	r.RegisterObjectHandler(reflect.TypeOf(&auth.UserPrincipal{}), Handler)
+	r.RegisterObjectHandler(reflect.TypeOf(&auth.ClientPrincipal{}), Handler)
+	r.RegisterObjectHandler(reflect.TypeOf(&auth.SystemPrincipal{}), Handler)
+	r.RegisterObjectHandler(reflect.TypeOf(&auth.Anonymous{}), Handler)
+
+	// TODO: Добавить регистрацию schema, revision, service непонятно как делать
 }
 
 func init() {
diff --git a/id/user.go b/id/user.go
new file mode 100644
index 0000000000000000000000000000000000000000..ab8ddfa26d30fd720d137f0e56588061590f3a0e
--- /dev/null
+++ b/id/user.go
@@ -0,0 +1,54 @@
+package id
+
+import "fmt"
+
+const (
+	User        = "user"
+	UsersPrefix = "users"
+)
+
+type UserId struct {
+	UserID string `json:"user_id,omitempty" bson:"user_id,omitempty"`
+}
+
+var _ Descriptor = &UserId{}
+
+func (id *UserId) New() Descriptor {
+	return &UserId{}
+}
+
+func (id *UserId) Type() string { return User }
+
+func (id *UserId) String() string {
+	return Join(UsersPrefix, id.UserID)
+}
+
+func (id *UserId) FromParts(parts []string) error {
+	if len(parts) != 2 || parts[0] != UsersPrefix {
+		return ErrInvalid
+	}
+	id.UserID = parts[1]
+	return nil
+}
+
+func (id *UserId) Map() map[string]any {
+	return map[string]any{
+		"user_id": id.UserID,
+		"type":    id.Type(),
+	}
+}
+
+func (id *UserId) FromMap(m map[string]any) error {
+	id.UserID, _ = m["user_id"].(string)
+	if id.UserID == "" {
+		return fmt.Errorf("%w: UserId required", ErrInvalid)
+	}
+	return nil
+}
+
+func (id *UserId) Validate() error {
+	if id.UserID == "" {
+		return fmt.Errorf("%w: UserId required", ErrInvalid)
+	}
+	return nil
+}
diff --git a/log/log.go b/log/log.go
index d21ddbcaaa262c4c16e95a35cd098f77ea4a53cb..8ac1494933bfc36d2beef878a7b771ee7983a178 100644
--- a/log/log.go
+++ b/log/log.go
@@ -27,17 +27,17 @@ func (l Level) String() string {
 }
 
 type Entry struct {
-	ID        string      `json:"id" bson:"id" mapstructure:"id"`
-	Timestamp time.Time   `json:"timestamp,omitempty" bson:"timestamp,omitempty" mapstructure:"timestamp,omitempty"`
-	LogLevel  Level       `json:"log_level,omitempty" bson:"log_level,omitempty" mapstructure:"log_level,omitempty"`
-	Message   string      `json:"message,omitempty" bson:"message,omitempty" mapstructure:"message,omitempty"`
-	Category  string      `json:"category,omitempty" bson:"category,omitempty" mapstructure:"category,omitempty"`
-	Component string      `json:"component,omitempty" bson:"component,omitempty" mapstructure:"component,omitempty"`
-	Event     string      `json:"event,omitempty" bson:"event,omitempty" mapstructure:"event,omitempty"`
-	ObjectID  *id.ID      `json:"object_id,omitempty" bson:"object_id,omitempty" mapstructure:"object_id,omitempty"`
-	CallerID  *id.ID      `json:"caller_id,omitempty" bson:"caller_id,omitempty" mapstructure:"caller_id,omitempty"`
-	Attr      interface{} `json:"attr,omitempty" bson:"attr,omitempty" mapstructure:"attr,omitempty"`
-	Tags      []string    `json:"tags,omitempty" bson:"tags,omitempty" mapstructure:"tags,omitempty"`
+	ID        string       `json:"id" bson:"id" mapstructure:"id"`
+	Timestamp time.Time    `json:"timestamp,omitempty" bson:"timestamp,omitempty" mapstructure:"timestamp,omitempty"`
+	LogLevel  Level        `json:"log_level,omitempty" bson:"log_level,omitempty" mapstructure:"log_level,omitempty"`
+	Message   string       `json:"message,omitempty" bson:"message,omitempty" mapstructure:"message,omitempty"`
+	Category  string       `json:"category,omitempty" bson:"category,omitempty" mapstructure:"category,omitempty"`
+	Component string       `json:"component,omitempty" bson:"component,omitempty" mapstructure:"component,omitempty"`
+	Event     string       `json:"event,omitempty" bson:"event,omitempty" mapstructure:"event,omitempty"`
+	ObjectID  *id.ObjectId `json:"object_id,omitempty" bson:"object_id,omitempty" mapstructure:"object_id,omitempty"`
+	CallerID  *id.ObjectId `json:"caller_id,omitempty" bson:"caller_id,omitempty" mapstructure:"caller_id,omitempty"`
+	Attr      interface{}  `json:"attr,omitempty" bson:"attr,omitempty" mapstructure:"attr,omitempty"`
+	Tags      []string     `json:"tags,omitempty" bson:"tags,omitempty" mapstructure:"tags,omitempty"`
 }
 
 //func convertInterfaceToAny(v interface{}) (*any.Any, error) {
@@ -84,10 +84,10 @@ func EntryFromPB(request *pb.LogEntry) *Entry {
 	}
 
 	if request.ObjectId != "" {
-		logEntry.ObjectID, _ = id.Parse(request.ObjectId)
+		logEntry.ObjectID = id.MustObjectId(request.ObjectId)
 	}
 	if request.CallerId != "" {
-		logEntry.CallerID, _ = id.Parse(request.CallerId)
+		logEntry.CallerID = id.MustObjectId(request.CallerId)
 	}
 	if request.Attr != nil {
 		logEntry.Attr = request.Attr // todo: как с этим работать?
@@ -111,11 +111,11 @@ func (e *Entry) ToMap() map[string]any {
 	}
 	if e.ObjectID != nil {
 		res["object_id"] = e.ObjectID.String()
-		res["object"] = e.ObjectID.ToMap()
+		res["object"] = e.ObjectID.Map()
 	}
 	if e.CallerID != nil {
 		res["caller_id"] = e.CallerID.String()
-		res["caller"] = e.CallerID.ToMap()
+		res["caller"] = e.CallerID.Map()
 	}
 	if e.Attr != nil {
 		res["attr"] = e.Attr
diff --git a/log/log_test.go b/log/log_test.go
index 08d78f594dcaeae0c72557401f70c4d026e918b2..72ab7d3c10459a8be5464f9bd51546f33df3e5f7 100644
--- a/log/log_test.go
+++ b/log/log_test.go
@@ -17,8 +17,8 @@ func TestEntry_ToMap(t *testing.T) {
 		Category  string
 		Component string
 		Event     string
-		ObjectId  *id.ID
-		CallerId  *id.ID
+		ObjectId  *id.ObjectId
+		CallerId  *id.ObjectId
 		Attr      interface{}
 		Tags      []string
 	}
@@ -37,8 +37,8 @@ func TestEntry_ToMap(t *testing.T) {
 				"",
 				"",
 				"",
-				id.NewEnvironmentID("<space_id>", "<env_id>"),
-				id.NewUserID("<user_id>"),
+				id.MustObjectId("/spaces/<space_id>/envs/<env_id>"),
+				id.MustObjectId("/users/<user_id>"),
 				nil,
 				nil,
 			},