object/typ: Remove Type prefix from object/typ.Type literals

47 files changed, 173 insertions, 173 deletions

diff --git a/object/blob/append.go b/object/blob/append.go
index 378e4edb..2376d65f 100644
--- a/object/blob/append.go
+++ b/object/blob/append.go
@@ -12,7 +12,7 @@ func (blob *Blob) AppendWithoutHeader(dst []byte) ([]byte, error) {
 
 // AppendWithHeader renders the raw object (header + body).
 func (blob *Blob) AppendWithHeader(dst []byte) ([]byte, error) {
-	dst = header.Append(dst, typ.TypeBlob, uint64(len(blob.Data)))
+	dst = header.Append(dst, typ.Blob, uint64(len(blob.Data)))
 
 	return blob.AppendWithoutHeader(dst)
 }
diff --git a/object/blob/type.go b/object/blob/type.go
index 9669e038..c2d23e13 100644
--- a/object/blob/type.go
+++ b/object/blob/type.go
@@ -6,5 +6,5 @@ import "lindenii.org/go/furgit/object/typ"
 func (blob *Blob) ObjectType() typ.Type {
 	_ = blob
 
-	return typ.TypeBlob
+	return typ.Blob
 }
diff --git a/object/commit/append.go b/object/commit/append.go
index 84410b80..b637620e 100644
--- a/object/commit/append.go
+++ b/object/commit/append.go
@@ -61,7 +61,7 @@ func (commit *Commit) AppendWithHeader(dst []byte) ([]byte, error) {
 		return dst, err
 	}
 
-	dst = header.Append(dst, typ.TypeCommit, uint64(len(body)))
+	dst = header.Append(dst, typ.Commit, uint64(len(body)))
 
 	return append(dst, body...), nil
 }
diff --git a/object/commit/append_test.go b/object/commit/append_test.go
index ca32903f..7a54f19e 100644
--- a/object/commit/append_test.go
+++ b/object/commit/append_test.go
@@ -24,13 +24,13 @@ func TestAppendGitFsck(t *testing.T) {
 				t.Fatalf("NewRepo: %v", err)
 			}
 
-			blobID, err := repo.HashObject(t, typ.TypeBlob, strings.NewReader("content\n"))
+			blobID, err := repo.HashObject(t, typ.Blob, strings.NewReader("content\n"))
 			if err != nil {
 				t.Fatalf("HashObject(blob): %v", err)
 			}
 
 			treeID, err := repo.MkTree(t, []testgit.TreeEntry{
-				{Mode: "100644", Type: typ.TypeBlob, OID: blobID, Name: "file.txt"},
+				{Mode: "100644", Type: typ.Blob, OID: blobID, Name: "file.txt"},
 			})
 			if err != nil {
 				t.Fatalf("MkTree: %v", err)
@@ -58,7 +58,7 @@ func TestAppendGitFsck(t *testing.T) {
 				t.Fatalf("AppendWithoutHeader: %v", err)
 			}
 
-			commitID, err := repo.HashObject(t, typ.TypeCommit, bytes.NewReader(rawBody))
+			commitID, err := repo.HashObject(t, typ.Commit, bytes.NewReader(rawBody))
 			if err != nil {
 				t.Fatalf("HashObject(commit): %v", err)
 			}
diff --git a/object/commit/parse_test.go b/object/commit/parse_test.go
index 48202676..2264f84d 100644
--- a/object/commit/parse_test.go
+++ b/object/commit/parse_test.go
@@ -39,13 +39,13 @@ func TestParse(t *testing.T) {
 				t.Fatalf("NewRepo: %v", err)
 			}
 
-			blobID, err := repo.HashObject(t, typ.TypeBlob, strings.NewReader("content\n"))
+			blobID, err := repo.HashObject(t, typ.Blob, strings.NewReader("content\n"))
 			if err != nil {
 				t.Fatalf("HashObject: %v", err)
 			}
 
 			treeID, err := repo.MkTree(t, []testgit.TreeEntry{
-				{Mode: "100644", Type: typ.TypeBlob, OID: blobID, Name: "file.txt"},
+				{Mode: "100644", Type: typ.Blob, OID: blobID, Name: "file.txt"},
 			})
 			if err != nil {
 				t.Fatalf("MkTree: %v", err)
@@ -96,7 +96,7 @@ func TestParse(t *testing.T) {
 				},
 			} {
 				t.Run(tc.name, func(t *testing.T) {
-					rawBody, err := repo.CatFile(t, typ.TypeCommit, tc.oid)
+					rawBody, err := repo.CatFile(t, typ.Commit, tc.oid)
 					if err != nil {
 						t.Fatalf("CatFile: %v", err)
 					}
diff --git a/object/commit/roundtrip_test.go b/object/commit/roundtrip_test.go
index 8169e75f..faa8a834 100644
--- a/object/commit/roundtrip_test.go
+++ b/object/commit/roundtrip_test.go
@@ -25,13 +25,13 @@ func TestRoundTrip(t *testing.T) {
 				t.Fatalf("NewRepo: %v", err)
 			}
 
-			blobID, err := repo.HashObject(t, typ.TypeBlob, strings.NewReader("roundtrip\n"))
+			blobID, err := repo.HashObject(t, typ.Blob, strings.NewReader("roundtrip\n"))
 			if err != nil {
 				t.Fatalf("HashObject(blob): %v", err)
 			}
 
 			treeID, err := repo.MkTree(t, []testgit.TreeEntry{
-				{Mode: "100644", Type: typ.TypeBlob, OID: blobID, Name: "roundtrip.txt"},
+				{Mode: "100644", Type: typ.Blob, OID: blobID, Name: "roundtrip.txt"},
 			})
 			if err != nil {
 				t.Fatalf("MkTree: %v", err)
@@ -99,7 +99,7 @@ func TestRoundTrip(t *testing.T) {
 				t.Fatalf("AppendWithoutHeader: %v", err)
 			}
 
-			roundTripID, err := repo.HashObject(t, typ.TypeCommit, bytes.NewReader(rawBody))
+			roundTripID, err := repo.HashObject(t, typ.Commit, bytes.NewReader(rawBody))
 			if err != nil {
 				t.Fatalf("HashObject(commit): %v", err)
 			}
@@ -112,7 +112,7 @@ func TestRoundTrip(t *testing.T) {
 				t.Fatalf("Fsck: %v", err)
 			}
 
-			gitBody, err := repo.CatFile(t, typ.TypeCommit, roundTripID)
+			gitBody, err := repo.CatFile(t, typ.Commit, roundTripID)
 			if err != nil {
 				t.Fatalf("CatFile: %v", err)
 			}
diff --git a/object/commit/type.go b/object/commit/type.go
index 80715a72..2ec67320 100644
--- a/object/commit/type.go
+++ b/object/commit/type.go
@@ -8,5 +8,5 @@ import (
 func (commit *Commit) ObjectType() typ.Type {
 	_ = commit
 
-	return typ.TypeCommit
+	return typ.Commit
 }
diff --git a/object/fetch/blob.go b/object/fetch/blob.go
index 581fff90..9af34922 100644
--- a/object/fetch/blob.go
+++ b/object/fetch/blob.go
@@ -22,7 +22,7 @@ func (fetcher *Fetcher) ExactBlob(id oid.ObjectID) (*stored.Stored[*blob.Blob],
 
 	blob, ok := parsed.(*blob.Blob)
 	if !ok {
-		return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.TypeBlob}
+		return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.Blob}
 	}
 
 	return stored.New(id, blob), nil
@@ -33,7 +33,7 @@ func (fetcher *Fetcher) ExactBlob(id oid.ObjectID) (*stored.Stored[*blob.Blob],
 //
 // Labels: Life-Parent, Close-Caller.
 func (fetcher *Fetcher) ExactBlobReader(id oid.ObjectID) (io.ReadCloser, uint64, error) {
-	return fetcher.exactReader(id, typ.TypeBlob)
+	return fetcher.exactReader(id, typ.Blob)
 }
 
 // PeelToBlob peels tags until it reaches a blob.
@@ -52,7 +52,7 @@ func (fetcher *Fetcher) PeelToBlob(id oid.ObjectID) (*stored.Stored[*blob.Blob],
 		case *tag.Tag:
 			id = parsed.TargetID
 		default:
-			return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.TypeBlob}
+			return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.Blob}
 		}
 	}
 }
@@ -66,19 +66,19 @@ func (fetcher *Fetcher) PeelToBlobID(id oid.ObjectID) (oid.ObjectID, error) {
 		}
 
 		switch ty {
-		case typ.TypeBlob:
+		case typ.Blob:
 			return id, nil
-		case typ.TypeTag:
+		case typ.Tag:
 			tag, err := fetcher.ExactTag(id)
 			if err != nil {
 				return oid.ObjectID{}, err
 			}
 
 			id = tag.Object().TargetID
-		case typ.TypeUnknown, typ.TypeCommit, typ.TypeTree:
-			return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.TypeBlob}
+		case typ.Unknown, typ.Commit, typ.Tree:
+			return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.Blob}
 		default:
-			return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.TypeBlob}
+			return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.Blob}
 		}
 	}
 }
diff --git a/object/fetch/commit.go b/object/fetch/commit.go
index 5d5af892..f6f308e8 100644
--- a/object/fetch/commit.go
+++ b/object/fetch/commit.go
@@ -20,7 +20,7 @@ func (fetcher *Fetcher) ExactCommit(id oid.ObjectID) (*stored.Stored[*commit.Com
 
 	commit, ok := parsed.(*commit.Commit)
 	if !ok {
-		return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.TypeCommit}
+		return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.Commit}
 	}
 
 	return stored.New(id, commit), nil
@@ -42,7 +42,7 @@ func (fetcher *Fetcher) PeelToCommit(id oid.ObjectID) (*stored.Stored[*commit.Co
 		case *tag.Tag:
 			id = parsed.TargetID
 		default:
-			return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.TypeCommit}
+			return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.Commit}
 		}
 	}
 }
@@ -56,19 +56,19 @@ func (fetcher *Fetcher) PeelToCommitID(id oid.ObjectID) (oid.ObjectID, error) {
 		}
 
 		switch ty {
-		case typ.TypeCommit:
+		case typ.Commit:
 			return id, nil
-		case typ.TypeTag:
+		case typ.Tag:
 			tag, err := fetcher.ExactTag(id)
 			if err != nil {
 				return oid.ObjectID{}, err
 			}
 
 			id = tag.Object().TargetID
-		case typ.TypeUnknown, typ.TypeTree, typ.TypeBlob:
-			return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.TypeCommit}
+		case typ.Unknown, typ.Tree, typ.Blob:
+			return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.Commit}
 		default:
-			return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.TypeCommit}
+			return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.Commit}
 		}
 	}
 }
diff --git a/object/fetch/header.go b/object/fetch/header.go
index d8cc7644..7a8df483 100644
--- a/object/fetch/header.go
+++ b/object/fetch/header.go
@@ -11,7 +11,7 @@ import (
 func (fetcher *Fetcher) Header(id oid.ObjectID) (typ.Type, uint64, error) {
 	ty, size, err := fetcher.store.ReadHeader(id)
 	if err != nil {
-		return typ.TypeUnknown, 0, wrapObjectReadError(id, err)
+		return typ.Unknown, 0, wrapObjectReadError(id, err)
 	}
 
 	return ty, size, nil
diff --git a/object/fetch/tag.go b/object/fetch/tag.go
index 326244d8..205bb127 100644
--- a/object/fetch/tag.go
+++ b/object/fetch/tag.go
@@ -19,7 +19,7 @@ func (fetcher *Fetcher) ExactTag(id oid.ObjectID) (*stored.Stored[*tag.Tag], err
 
 	tag, ok := parsed.(*tag.Tag)
 	if !ok {
-		return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.TypeTag}
+		return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.Tag}
 	}
 
 	return stored.New(id, tag), nil
diff --git a/object/fetch/tree.go b/object/fetch/tree.go
index add41274..9ac3875f 100644
--- a/object/fetch/tree.go
+++ b/object/fetch/tree.go
@@ -21,7 +21,7 @@ func (fetcher *Fetcher) ExactTree(id oid.ObjectID) (*stored.Stored[*tree.Tree],
 
 	tree, ok := parsed.(*tree.Tree)
 	if !ok {
-		return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.TypeTree}
+		return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.Tree}
 	}
 
 	return stored.New(id, tree), nil
@@ -46,7 +46,7 @@ func (fetcher *Fetcher) PeelToTree(id oid.ObjectID) (*stored.Stored[*tree.Tree],
 		case *tag.Tag:
 			id = parsed.TargetID
 		default:
-			return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.TypeTree}
+			return nil, &errs.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: typ.Tree}
 		}
 	}
 }
@@ -61,26 +61,26 @@ func (fetcher *Fetcher) PeelToTreeID(id oid.ObjectID) (oid.ObjectID, error) {
 		}
 
 		switch ty {
-		case typ.TypeTree:
+		case typ.Tree:
 			return id, nil
-		case typ.TypeCommit:
+		case typ.Commit:
 			commit, err := fetcher.ExactCommit(id)
 			if err != nil {
 				return oid.ObjectID{}, err
 			}
 
 			return commit.Object().Tree, nil
-		case typ.TypeTag:
+		case typ.Tag:
 			tag, err := fetcher.ExactTag(id)
 			if err != nil {
 				return oid.ObjectID{}, err
 			}
 
 			id = tag.Object().TargetID
-		case typ.TypeUnknown, typ.TypeBlob:
-			return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.TypeTree}
+		case typ.Unknown, typ.Blob:
+			return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.Tree}
 		default:
-			return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.TypeTree}
+			return oid.ObjectID{}, &errs.ObjectTypeError{OID: id, Got: ty, Want: typ.Tree}
 		}
 	}
 }
diff --git a/object/fetch/treefs_test.go b/object/fetch/treefs_test.go
index 73f1c591..ba292276 100644
--- a/object/fetch/treefs_test.go
+++ b/object/fetch/treefs_test.go
@@ -24,12 +24,12 @@ func TestTreeFS(t *testing.T) {
 
 			store := memory.New(objectFormat)
 
-			plainID, err := store.WriteBytesContent(typ.TypeBlob, []byte("plain\n"))
+			plainID, err := store.WriteBytesContent(typ.Blob, []byte("plain\n"))
 			if err != nil {
 				t.Fatalf("WriteBytesContent(plain.txt): %v", err)
 			}
 
-			execID, err := store.WriteBytesContent(typ.TypeBlob, []byte("#!/bin/sh\nexit 0\n"))
+			execID, err := store.WriteBytesContent(typ.Blob, []byte("#!/bin/sh\nexit 0\n"))
 			if err != nil {
 				t.Fatalf("WriteBytesContent(exec.sh): %v", err)
 			}
@@ -133,7 +133,7 @@ func writeTree(t *testing.T, store *memory.Memory, entries []tree.Entry) id.Obje
 		t.Fatalf("tree.AppendWithoutHeader: %v", err)
 	}
 
-	treeID, err := store.WriteBytesContent(typ.TypeTree, body)
+	treeID, err := store.WriteBytesContent(typ.Tree, body)
 	if err != nil {
 		t.Fatalf("WriteBytesContent(tree): %v", err)
 	}
@@ -163,7 +163,7 @@ func writeCommit(t *testing.T, store *memory.Memory, tree id.ObjectID) id.Object
 		t.Fatalf("commit.AppendWithoutHeader: %v", err)
 	}
 
-	commitID, err := store.WriteBytesContent(typ.TypeCommit, body)
+	commitID, err := store.WriteBytesContent(typ.Commit, body)
 	if err != nil {
 		t.Fatalf("WriteBytesContent(commit): %v", err)
 	}
diff --git a/object/parse.go b/object/parse.go
index 81996206..afcdfe28 100644
--- a/object/parse.go
+++ b/object/parse.go
@@ -41,15 +41,15 @@ func ParseWithHeader(raw []byte, objectFormat id.ObjectFormat) (Object, error) {
 //nolint:ireturn
 func ParseWithoutHeader(ty typ.Type, body []byte, objectFormat id.ObjectFormat) (Object, error) {
 	switch ty {
-	case typ.TypeBlob:
+	case typ.Blob:
 		return blob.Parse(body) //nolint:wrapcheck
-	case typ.TypeTree:
+	case typ.Tree:
 		return tree.Parse(body, objectFormat) //nolint:wrapcheck
-	case typ.TypeCommit:
+	case typ.Commit:
 		return commit.Parse(body, objectFormat) //nolint:wrapcheck
-	case typ.TypeTag:
+	case typ.Tag:
 		return tag.Parse(body, objectFormat) //nolint:wrapcheck
-	case typ.TypeUnknown:
+	case typ.Unknown:
 		return nil, typ.ErrInvalidType
 	default:
 		return nil, typ.ErrInvalidType
diff --git a/object/signed/commit/verify_test.go b/object/signed/commit/verify_test.go
index fa7dea2f..1133f44b 100644
--- a/object/signed/commit/verify_test.go
+++ b/object/signed/commit/verify_test.go
@@ -79,13 +79,13 @@ func setupSSHSignedCommit(
 		t.Fatalf("ConfigSet(user.signingkey): %v", err)
 	}
 
-	blobID, err := repo.HashObject(t, typ.TypeBlob, strings.NewReader("signed\n"))
+	blobID, err := repo.HashObject(t, typ.Blob, strings.NewReader("signed\n"))
 	if err != nil {
 		t.Fatalf("HashObject(blob): %v", err)
 	}
 
 	treeID, err := repo.MkTree(t, []testgit.TreeEntry{
-		{Mode: "100644", Type: typ.TypeBlob, OID: blobID, Name: "file.txt"},
+		{Mode: "100644", Type: typ.Blob, OID: blobID, Name: "file.txt"},
 	})
 	if err != nil {
 		t.Fatalf("MkTree: %v", err)
@@ -99,7 +99,7 @@ func setupSSHSignedCommit(
 		t.Fatalf("CommitTree: %v", err)
 	}
 
-	body, err := repo.CatFile(t, typ.TypeCommit, commitID)
+	body, err := repo.CatFile(t, typ.Commit, commitID)
 	if err != nil {
 		t.Fatalf("CatFile: %v", err)
 	}
diff --git a/object/signed/tag/verify_test.go b/object/signed/tag/verify_test.go
index aea21b40..3b149082 100644
--- a/object/signed/tag/verify_test.go
+++ b/object/signed/tag/verify_test.go
@@ -79,13 +79,13 @@ func setupSSHSignedTag(
 		t.Fatalf("ConfigSet(user.signingkey): %v", err)
 	}
 
-	blobID, err := repo.HashObject(t, typ.TypeBlob, strings.NewReader("signed\n"))
+	blobID, err := repo.HashObject(t, typ.Blob, strings.NewReader("signed\n"))
 	if err != nil {
 		t.Fatalf("HashObject(blob): %v", err)
 	}
 
 	treeID, err := repo.MkTree(t, []testgit.TreeEntry{
-		{Mode: "100644", Type: typ.TypeBlob, OID: blobID, Name: "file.txt"},
+		{Mode: "100644", Type: typ.Blob, OID: blobID, Name: "file.txt"},
 	})
 	if err != nil {
 		t.Fatalf("MkTree: %v", err)
@@ -106,7 +106,7 @@ func setupSSHSignedTag(
 		t.Fatalf("TagAnnotated: %v", err)
 	}
 
-	body, err := repo.CatFile(t, typ.TypeTag, tagID)
+	body, err := repo.CatFile(t, typ.Tag, tagID)
 	if err != nil {
 		t.Fatalf("CatFile: %v", err)
 	}
diff --git a/object/store/chain/bytes.go b/object/store/chain/bytes.go
index fe045d0f..1739fcaa 100644
--- a/object/store/chain/bytes.go
+++ b/object/store/chain/bytes.go
@@ -41,8 +41,8 @@ func (chain *Chain) ReadBytesContent(id id.ObjectID) (typ.Type, []byte, error) {
 			continue
 		}
 
-		return typ.TypeUnknown, nil, fmt.Errorf("object/store/chain: read bytes content: %w", err)
+		return typ.Unknown, nil, fmt.Errorf("object/store/chain: read bytes content: %w", err)
 	}
 
-	return typ.TypeUnknown, nil, store.ErrObjectNotFound
+	return typ.Unknown, nil, store.ErrObjectNotFound
 }
diff --git a/object/store/chain/header.go b/object/store/chain/header.go
index 2efd16a4..c12fc27f 100644
--- a/object/store/chain/header.go
+++ b/object/store/chain/header.go
@@ -22,10 +22,10 @@ func (chain *Chain) ReadHeader(id id.ObjectID) (typ.Type, uint64, error) {
 			continue
 		}
 
-		return typ.TypeUnknown, 0, fmt.Errorf("object/store/chain: read header: %w", err)
+		return typ.Unknown, 0, fmt.Errorf("object/store/chain: read header: %w", err)
 	}
 
-	return typ.TypeUnknown, 0, store.ErrObjectNotFound
+	return typ.Unknown, 0, store.ErrObjectNotFound
 }
 
 // ReadSize reads object content length
diff --git a/object/store/chain/reader.go b/object/store/chain/reader.go
index 2e0f317e..744838dd 100644
--- a/object/store/chain/reader.go
+++ b/object/store/chain/reader.go
@@ -42,8 +42,8 @@ func (chain *Chain) ReadReaderContent(id id.ObjectID) (typ.Type, uint64, io.Read
 			continue
 		}
 
-		return typ.TypeUnknown, 0, nil, fmt.Errorf("object/store/chain: read reader content: %w", err)
+		return typ.Unknown, 0, nil, fmt.Errorf("object/store/chain: read reader content: %w", err)
 	}
 
-	return typ.TypeUnknown, 0, nil, store.ErrObjectNotFound
+	return typ.Unknown, 0, nil, store.ErrObjectNotFound
 }
diff --git a/object/store/loose/helpers_test.go b/object/store/loose/helpers_test.go
index 22641049..abfc53e6 100644
--- a/object/store/loose/helpers_test.go
+++ b/object/store/loose/helpers_test.go
@@ -52,13 +52,13 @@ func openLooseStore(t *testing.T, repo *testgit.Repo) *loose.Loose {
 func gitOracleObjects(t *testing.T, repo *testgit.Repo) []gitOracleObject {
 	t.Helper()
 
-	blobID, err := repo.HashObject(t, typ.TypeBlob, strings.NewReader("blob body\n"))
+	blobID, err := repo.HashObject(t, typ.Blob, strings.NewReader("blob body\n"))
 	if err != nil {
 		t.Fatalf("HashObject(blob): %v", err)
 	}
 
 	treeID, err := repo.MkTree(t, []testgit.TreeEntry{
-		{Mode: "100644", Type: typ.TypeBlob, OID: blobID, Name: "file"},
+		{Mode: "100644", Type: typ.Blob, OID: blobID, Name: "file"},
 	})
 	if err != nil {
 		t.Fatalf("MkTree: %v", err)
@@ -79,10 +79,10 @@ func gitOracleObjects(t *testing.T, repo *testgit.Repo) []gitOracleObject {
 		ty   typ.Type
 		id   id.ObjectID
 	}{
-		{name: "blob", ty: typ.TypeBlob, id: blobID},
-		{name: "tree", ty: typ.TypeTree, id: treeID},
-		{name: "commit", ty: typ.TypeCommit, id: commitID},
-		{name: "tag", ty: typ.TypeTag, id: tagID},
+		{name: "blob", ty: typ.Blob, id: blobID},
+		{name: "tree", ty: typ.Tree, id: treeID},
+		{name: "commit", ty: typ.Commit, id: commitID},
+		{name: "tag", ty: typ.Tag, id: tagID},
 	}
 
 	objects := make([]gitOracleObject, 0, len(kinds))
diff --git a/object/store/loose/parse.go b/object/store/loose/parse.go
index 96448c6e..abfd527b 100644
--- a/object/store/loose/parse.go
+++ b/object/store/loose/parse.go
@@ -33,12 +33,12 @@ func decodeAll(file *os.File) ([]byte, error) {
 func parseRaw(raw []byte) (typ.Type, []byte, error) {
 	ty, size, consumed, err := header.Parse(raw)
 	if err != nil {
-		return typ.TypeUnknown, nil, fmt.Errorf("%w: %w", store.ErrInvalidObject, err)
+		return typ.Unknown, nil, fmt.Errorf("%w: %w", store.ErrInvalidObject, err)
 	}
 
 	content := raw[consumed:]
 	if uint64(len(content)) != size {
-		return typ.TypeUnknown, nil, fmt.Errorf("%w: header size/content mismatch", store.ErrInvalidObject)
+		return typ.Unknown, nil, fmt.Errorf("%w: header size/content mismatch", store.ErrInvalidObject)
 	}
 
 	return ty, content, nil
@@ -49,12 +49,12 @@ func parseRaw(raw []byte) (typ.Type, []byte, error) {
 func readHeader(br *bufio.Reader) ([]byte, typ.Type, uint64, error) {
 	headerBytes, err := br.ReadSlice(0)
 	if err != nil {
-		return nil, typ.TypeUnknown, 0, fmt.Errorf("object/store/loose: %w", err)
+		return nil, typ.Unknown, 0, fmt.Errorf("object/store/loose: %w", err)
 	}
 
 	ty, size, _, err := header.Parse(headerBytes)
 	if err != nil {
-		return nil, typ.TypeUnknown, 0, fmt.Errorf("%w: %w", store.ErrInvalidObject, err)
+		return nil, typ.Unknown, 0, fmt.Errorf("%w: %w", store.ErrInvalidObject, err)
 	}
 
 	return headerBytes, ty, size, nil
diff --git a/object/store/loose/quarantine_test.go b/object/store/loose/quarantine_test.go
index 2aab6566..148d4221 100644
--- a/object/store/loose/quarantine_test.go
+++ b/object/store/loose/quarantine_test.go
@@ -32,7 +32,7 @@ func TestQuarantinePromote(t *testing.T) {
 
 			content := []byte("quarantined object\n")
 
-			objectID, err := quarantine.WriteBytesContent(typ.TypeBlob, content)
+			objectID, err := quarantine.WriteBytesContent(typ.Blob, content)
 			if err != nil {
 				t.Fatalf("quarantine.WriteBytesContent: %v", err)
 			}
@@ -42,8 +42,8 @@ func TestQuarantinePromote(t *testing.T) {
 				t.Fatalf("quarantine.ReadBytesContent: %v", err)
 			}
 
-			if ty != typ.TypeBlob {
-				t.Fatalf("quarantine type = %v, want %v", ty, typ.TypeBlob)
+			if ty != typ.Blob {
+				t.Fatalf("quarantine type = %v, want %v", ty, typ.Blob)
 			}
 
 			if !bytes.Equal(got, content) {
@@ -65,8 +65,8 @@ func TestQuarantinePromote(t *testing.T) {
 				t.Fatalf("parent ReadBytesContent after promote: %v", err)
 			}
 
-			if ty != typ.TypeBlob {
-				t.Fatalf("parent type = %v, want %v", ty, typ.TypeBlob)
+			if ty != typ.Blob {
+				t.Fatalf("parent type = %v, want %v", ty, typ.Blob)
 			}
 
 			if !bytes.Equal(got, content) {
@@ -97,7 +97,7 @@ func TestQuarantineDiscard(t *testing.T) {
 
 			content := []byte("discarded object\n")
 
-			objectID, err := quarantine.WriteBytesContent(typ.TypeBlob, content)
+			objectID, err := quarantine.WriteBytesContent(typ.Blob, content)
 			if err != nil {
 				t.Fatalf("quarantine.WriteBytesContent: %v", err)
 			}
diff --git a/object/store/loose/read_test.go b/object/store/loose/read_test.go
index fe8b8e7c..a0cea970 100644
--- a/object/store/loose/read_test.go
+++ b/object/store/loose/read_test.go
@@ -233,7 +233,7 @@ func TestReadCorruptTrailer(t *testing.T) {
 
 			content := []byte("corrupt-trailer-check\n")
 
-			objectID, err := looseStore.WriteBytesContent(typ.TypeBlob, content)
+			objectID, err := looseStore.WriteBytesContent(typ.Blob, content)
 			if err != nil {
 				t.Fatalf("WriteBytesContent: %v", err)
 			}
@@ -246,8 +246,8 @@ func TestReadCorruptTrailer(t *testing.T) {
 				t.Fatalf("ReadHeader: %v", err)
 			}
 
-			if ty != typ.TypeBlob {
-				t.Fatalf("ReadHeader type = %v, want %v", ty, typ.TypeBlob)
+			if ty != typ.Blob {
+				t.Fatalf("ReadHeader type = %v, want %v", ty, typ.Blob)
 			}
 
 			if size != uint64(len(content)) {
diff --git a/object/store/loose/reader.go b/object/store/loose/reader.go
index 940ce330..2e34f3f2 100644
--- a/object/store/loose/reader.go
+++ b/object/store/loose/reader.go
@@ -37,7 +37,7 @@ func (loose *Loose) ReadBytesFull(objectID id.ObjectID) ([]byte, error) {
 func (loose *Loose) ReadBytesContent(objectID id.ObjectID) (typ.Type, []byte, error) {
 	_, ty, content, err := loose.readBytesParsed(objectID)
 	if err != nil {
-		return typ.TypeUnknown, nil, err
+		return typ.Unknown, nil, err
 	}
 
 	return ty, content, nil
@@ -51,21 +51,21 @@ func (loose *Loose) ReadBytesContent(objectID id.ObjectID) (typ.Type, []byte, er
 func (loose *Loose) ReadHeader(objectID id.ObjectID) (typ.Type, uint64, error) {
 	file, err := loose.openObject(objectID)
 	if err != nil {
-		return typ.TypeUnknown, 0, err
+		return typ.Unknown, 0, err
 	}
 
 	defer func() { _ = file.Close() }()
 
 	zr, err := zlib.NewReader(file)
 	if err != nil {
-		return typ.TypeUnknown, 0, fmt.Errorf("object/store/loose: %w", err)
+		return typ.Unknown, 0, fmt.Errorf("object/store/loose: %w", err)
 	}
 
 	defer func() { _ = zr.Close() }()
 
 	_, ty, size, err := readHeader(bufio.NewReader(zr))
 	if err != nil {
-		return typ.TypeUnknown, 0, err
+		return typ.Unknown, 0, err
 	}
 
 	return ty, size, nil
@@ -130,7 +130,7 @@ func (loose *Loose) ReadReaderFull(objectID id.ObjectID) (io.ReadCloser, error)
 func (loose *Loose) ReadReaderContent(objectID id.ObjectID) (typ.Type, uint64, io.ReadCloser, error) {
 	file, zr, err := loose.openInflated(objectID)
 	if err != nil {
-		return typ.TypeUnknown, 0, nil, err
+		return typ.Unknown, 0, nil, err
 	}
 
 	br := bufio.NewReader(zr)
@@ -140,7 +140,7 @@ func (loose *Loose) ReadReaderContent(objectID id.ObjectID) (typ.Type, uint64, i
 		_ = zr.Close()
 		_ = file.Close()
 
-		return typ.TypeUnknown, 0, nil, err
+		return typ.Unknown, 0, nil, err
 	}
 
 	return ty, size, &objectReader{
@@ -180,19 +180,19 @@ func (loose *Loose) openObject(objectID id.ObjectID) (*os.File, error) {
 func (loose *Loose) readBytesParsed(objectID id.ObjectID) ([]byte, typ.Type, []byte, error) {
 	file, err := loose.openObject(objectID)
 	if err != nil {
-		return nil, typ.TypeUnknown, nil, err
+		return nil, typ.Unknown, nil, err
 	}
 
 	defer func() { _ = file.Close() }()
 
 	raw, err := decodeAll(file)
 	if err != nil {
-		return nil, typ.TypeUnknown, nil, err
+		return nil, typ.Unknown, nil, err
 	}
 
 	ty, content, err := parseRaw(raw)
 	if err != nil {
-		return nil, typ.TypeUnknown, nil, err
+		return nil, typ.Unknown, nil, err
 	}
 
 	return raw, ty, content, nil
diff --git a/object/store/loose/roundtrip_test.go b/object/store/loose/roundtrip_test.go
index e99da0f2..1f65667c 100644
--- a/object/store/loose/roundtrip_test.go
+++ b/object/store/loose/roundtrip_test.go
@@ -19,11 +19,11 @@ func TestRoundTrip(t *testing.T) {
 		ty      typ.Type
 		content []byte
 	}{
-		{name: "blob", ty: typ.TypeBlob, content: []byte("roundtrip blob\n")},
-		{name: "empty blob", ty: typ.TypeBlob, content: []byte{}},
-		{name: "tree", ty: typ.TypeTree, content: []byte("roundtrip tree bytes")},
-		{name: "commit", ty: typ.TypeCommit, content: []byte("roundtrip commit bytes")},
-		{name: "tag", ty: typ.TypeTag, content: []byte("roundtrip tag bytes")},
+		{name: "blob", ty: typ.Blob, content: []byte("roundtrip blob\n")},
+		{name: "empty blob", ty: typ.Blob, content: []byte{}},
+		{name: "tree", ty: typ.Tree, content: []byte("roundtrip tree bytes")},
+		{name: "commit", ty: typ.Commit, content: []byte("roundtrip commit bytes")},
+		{name: "tag", ty: typ.Tag, content: []byte("roundtrip tag bytes")},
 	}
 
 	for _, objectFormat := range id.SupportedObjectFormats() {
diff --git a/object/store/loose/write_test.go b/object/store/loose/write_test.go
index 631b5fbc..4e9eb9d0 100644
--- a/object/store/loose/write_test.go
+++ b/object/store/loose/write_test.go
@@ -23,19 +23,19 @@ func TestWrite(t *testing.T) {
 		{
 			name: "BytesContent",
 			write: func(looseStore *loose.Loose, content []byte) (id.ObjectID, error) {
-				return looseStore.WriteBytesContent(typ.TypeBlob, content)
+				return looseStore.WriteBytesContent(typ.Blob, content)
 			},
 		},
 		{
 			name: "ReaderContent",
 			write: func(looseStore *loose.Loose, content []byte) (id.ObjectID, error) {
-				return looseStore.WriteReaderContent(typ.TypeBlob, uint64(len(content)), bytes.NewReader(content))
+				return looseStore.WriteReaderContent(typ.Blob, uint64(len(content)), bytes.NewReader(content))
 			},
 		},
 		{
 			name: "BytesFull",
 			write: func(looseStore *loose.Loose, content []byte) (id.ObjectID, error) {
-				raw := header.Append(nil, typ.TypeBlob, uint64(len(content)))
+				raw := header.Append(nil, typ.Blob, uint64(len(content)))
 				raw = append(raw, content...)
 
 				return looseStore.WriteBytesFull(raw)
@@ -44,7 +44,7 @@ func TestWrite(t *testing.T) {
 		{
 			name: "ReaderFull",
 			write: func(looseStore *loose.Loose, content []byte) (id.ObjectID, error) {
-				raw := header.Append(nil, typ.TypeBlob, uint64(len(content)))
+				raw := header.Append(nil, typ.Blob, uint64(len(content)))
 				raw = append(raw, content...)
 
 				return looseStore.WriteReaderFull(bytes.NewReader(raw))
@@ -67,7 +67,7 @@ func TestWrite(t *testing.T) {
 				t.Run(w.name, func(t *testing.T) {
 					content := []byte("written via " + w.name + "\n")
 
-					want, err := repo.HashObject(t, typ.TypeBlob, bytes.NewReader(content))
+					want, err := repo.HashObject(t, typ.Blob, bytes.NewReader(content))
 					if err != nil {
 						t.Fatalf("HashObject: %v", err)
 					}
@@ -81,7 +81,7 @@ func TestWrite(t *testing.T) {
 						t.Fatalf("id = %s, want %s", got, want)
 					}
 
-					gotBody, err := repo.CatFile(t, typ.TypeBlob, got)
+					gotBody, err := repo.CatFile(t, typ.Blob, got)
 					if err != nil {
 						t.Fatalf("CatFile: %v", err)
 					}
@@ -121,7 +121,7 @@ func TestWriteRejects(t *testing.T) {
 			t.Run("ContentOverflow", func(t *testing.T) {
 				t.Parallel()
 
-				_, err := looseStore.WriteReaderContent(typ.TypeBlob, 1, bytes.NewReader([]byte("hello")))
+				_, err := looseStore.WriteReaderContent(typ.Blob, 1, bytes.NewReader([]byte("hello")))
 				if !errors.Is(err, store.ErrInvalidObject) {
 					t.Fatalf("err = %v, want ErrInvalidObject", err)
 				}
@@ -130,7 +130,7 @@ func TestWriteRejects(t *testing.T) {
 			t.Run("ContentShort", func(t *testing.T) {
 				t.Parallel()
 
-				_, err := looseStore.WriteReaderContent(typ.TypeBlob, 5, bytes.NewReader([]byte("x")))
+				_, err := looseStore.WriteReaderContent(typ.Blob, 5, bytes.NewReader([]byte("x")))
 				if !errors.Is(err, store.ErrInvalidObject) {
 					t.Fatalf("err = %v, want ErrInvalidObject", err)
 				}
diff --git a/object/store/memory/reader.go b/object/store/memory/reader.go
index 19723a6c..bcde0a78 100644
--- a/object/store/memory/reader.go
+++ b/object/store/memory/reader.go
@@ -27,7 +27,7 @@ func (memory *Memory) ReadBytesFull(id id.ObjectID) ([]byte, error) {
 func (memory *Memory) ReadBytesContent(id id.ObjectID) (typ.Type, []byte, error) {
 	obj, ok := memory.objects.Load(id)
 	if !ok {
-		return typ.TypeUnknown, nil, store.ErrObjectNotFound
+		return typ.Unknown, nil, store.ErrObjectNotFound
 	}
 
 	return obj.ty, append([]byte(nil), obj.content...), nil
@@ -37,7 +37,7 @@ func (memory *Memory) ReadBytesContent(id id.ObjectID) (typ.Type, []byte, error)
 func (memory *Memory) ReadHeader(id id.ObjectID) (typ.Type, uint64, error) {
 	obj, ok := memory.objects.Load(id)
 	if !ok {
-		return typ.TypeUnknown, 0, store.ErrObjectNotFound
+		return typ.Unknown, 0, store.ErrObjectNotFound
 	}
 
 	return obj.ty, uint64(len(obj.content)), nil
@@ -67,7 +67,7 @@ func (memory *Memory) ReadReaderFull(id id.ObjectID) (io.ReadCloser, error) {
 func (memory *Memory) ReadReaderContent(id id.ObjectID) (typ.Type, uint64, io.ReadCloser, error) {
 	ty, content, err := memory.ReadBytesContent(id)
 	if err != nil {
-		return typ.TypeUnknown, 0, nil, err
+		return typ.Unknown, 0, nil, err
 	}
 
 	return ty, uint64(len(content)), io.NopCloser(bytes.NewReader(content)), nil
diff --git a/object/store/memory/writer_test.go b/object/store/memory/writer_test.go
index e68e1671..18223642 100644
--- a/object/store/memory/writer_test.go
+++ b/object/store/memory/writer_test.go
@@ -19,9 +19,9 @@ func TestWriteReaderContent(t *testing.T) {
 
 			store := memory.New(objectFormat)
 			content := []byte("memory-content\n")
-			raw := append(header.Append(nil, typ.TypeBlob, uint64(len(content))), content...)
+			raw := append(header.Append(nil, typ.Blob, uint64(len(content))), content...)
 
-			gotID, err := store.WriteReaderContent(typ.TypeBlob, uint64(len(content)), bytes.NewReader(content))
+			gotID, err := store.WriteReaderContent(typ.Blob, uint64(len(content)), bytes.NewReader(content))
 			if err != nil {
 				t.Fatalf("WriteReaderContent: %v", err)
 			}
@@ -36,8 +36,8 @@ func TestWriteReaderContent(t *testing.T) {
 				t.Fatalf("ReadBytesContent: %v", err)
 			}
 
-			if gotType != typ.TypeBlob {
-				t.Fatalf("ReadBytesContent type = %v, want %v", gotType, typ.TypeBlob)
+			if gotType != typ.Blob {
+				t.Fatalf("ReadBytesContent type = %v, want %v", gotType, typ.Blob)
 			}
 
 			if !bytes.Equal(gotContent, content) {
@@ -56,7 +56,7 @@ func TestWriteReaderFull(t *testing.T) {
 
 			store := memory.New(objectFormat)
 			content := []byte("memory-full\n")
-			raw := append(header.Append(nil, typ.TypeBlob, uint64(len(content))), content...)
+			raw := append(header.Append(nil, typ.Blob, uint64(len(content))), content...)
 
 			gotID, err := store.WriteReaderFull(bytes.NewReader(raw))
 			if err != nil {
@@ -89,9 +89,9 @@ func TestWriteBytes(t *testing.T) {
 
 			store := memory.New(objectFormat)
 			content := []byte("memory-bytes\n")
-			raw := append(header.Append(nil, typ.TypeBlob, uint64(len(content))), content...)
+			raw := append(header.Append(nil, typ.Blob, uint64(len(content))), content...)
 
-			gotID, err := store.WriteBytesContent(typ.TypeBlob, content)
+			gotID, err := store.WriteBytesContent(typ.Blob, content)
 			if err != nil {
 				t.Fatalf("WriteBytesContent: %v", err)
 			}
@@ -123,7 +123,7 @@ func TestWriteValidationErrors(t *testing.T) {
 		{
 			name: "content overflow",
 			run: func(store *memory.Memory) error {
-				_, err := store.WriteReaderContent(typ.TypeBlob, 1, bytes.NewReader([]byte("hello")))
+				_, err := store.WriteReaderContent(typ.Blob, 1, bytes.NewReader([]byte("hello")))
 
 				return err //nolint:wrapcheck
 			},
@@ -131,7 +131,7 @@ func TestWriteValidationErrors(t *testing.T) {
 		{
 			name: "content short",
 			run: func(store *memory.Memory) error {
-				_, err := store.WriteReaderContent(typ.TypeBlob, 5, bytes.NewReader([]byte("x")))
+				_, err := store.WriteReaderContent(typ.Blob, 5, bytes.NewReader([]byte("x")))
 
 				return err //nolint:wrapcheck
 			},
diff --git a/object/store/mix/bytes.go b/object/store/mix/bytes.go
index 2b4d3819..e76d16a9 100644
--- a/object/store/mix/bytes.go
+++ b/object/store/mix/bytes.go
@@ -45,8 +45,8 @@ func (mix *Mix) ReadBytesContent(id id.ObjectID) (typ.Type, []byte, error) {
 			continue
 		}
 
-		return typ.TypeUnknown, nil, fmt.Errorf("object/store/mix: read bytes content: %w", err)
+		return typ.Unknown, nil, fmt.Errorf("object/store/mix: read bytes content: %w", err)
 	}
 
-	return typ.TypeUnknown, nil, store.ErrObjectNotFound
+	return typ.Unknown, nil, store.ErrObjectNotFound
 }
diff --git a/object/store/mix/header.go b/object/store/mix/header.go
index 13dda9af..7f3c0b1b 100644
--- a/object/store/mix/header.go
+++ b/object/store/mix/header.go
@@ -24,10 +24,10 @@ func (mix *Mix) ReadHeader(id id.ObjectID) (typ.Type, uint64, error) {
 			continue
 		}
 
-		return typ.TypeUnknown, 0, fmt.Errorf("object/store/mix: read header: %w", err)
+		return typ.Unknown, 0, fmt.Errorf("object/store/mix: read header: %w", err)
 	}
 
-	return typ.TypeUnknown, 0, store.ErrObjectNotFound
+	return typ.Unknown, 0, store.ErrObjectNotFound
 }
 
 // ReadSize reads object content length
diff --git a/object/store/mix/reader.go b/object/store/mix/reader.go
index f9edc1a4..81b0474b 100644
--- a/object/store/mix/reader.go
+++ b/object/store/mix/reader.go
@@ -46,8 +46,8 @@ func (mix *Mix) ReadReaderContent(id id.ObjectID) (typ.Type, uint64, io.ReadClos
 			continue
 		}
 
-		return typ.TypeUnknown, 0, nil, fmt.Errorf("object/store/mix: read reader content: %w", err)
+		return typ.Unknown, 0, nil, fmt.Errorf("object/store/mix: read reader content: %w", err)
 	}
 
-	return typ.TypeUnknown, 0, nil, store.ErrObjectNotFound
+	return typ.Unknown, 0, nil, store.ErrObjectNotFound
 }
diff --git a/object/tag/append.go b/object/tag/append.go
index e3763ec7..bf519c55 100644
--- a/object/tag/append.go
+++ b/object/tag/append.go
@@ -47,7 +47,7 @@ func (tag *Tag) AppendWithHeader(dst []byte) ([]byte, error) {
 		return dst, err
 	}
 
-	dst = header.Append(dst, typ.TypeTag, uint64(len(body)))
+	dst = header.Append(dst, typ.Tag, uint64(len(body)))
 
 	return append(dst, body...), nil
 }
diff --git a/object/tag/append_test.go b/object/tag/append_test.go
index f72183a1..f4084b86 100644
--- a/object/tag/append_test.go
+++ b/object/tag/append_test.go
@@ -24,14 +24,14 @@ func TestAppend(t *testing.T) {
 				t.Fatalf("NewRepo: %v", err)
 			}
 
-			blobID, err := repo.HashObject(t, typ.TypeBlob, strings.NewReader("content\n"))
+			blobID, err := repo.HashObject(t, typ.Blob, strings.NewReader("content\n"))
 			if err != nil {
 				t.Fatalf("HashObject(blob): %v", err)
 			}
 
 			tagObject := &tag.Tag{
 				TargetID:   blobID,
-				TargetType: typ.TypeBlob,
+				TargetType: typ.Blob,
 				Name:       []byte("blob-tag"),
 				Tagger: signature.Signature{
 					Name:          []byte("Test Tagger"),
@@ -47,7 +47,7 @@ func TestAppend(t *testing.T) {
 				t.Fatalf("AppendWithoutHeader: %v", err)
 			}
 
-			tagID, err := repo.HashObject(t, typ.TypeTag, bytes.NewReader(rawBody))
+			tagID, err := repo.HashObject(t, typ.Tag, bytes.NewReader(rawBody))
 			if err != nil {
 				t.Fatalf("HashObject(tag): %v", err)
 			}
diff --git a/object/tag/parse_test.go b/object/tag/parse_test.go
index 0927b9c0..526d6207 100644
--- a/object/tag/parse_test.go
+++ b/object/tag/parse_test.go
@@ -23,13 +23,13 @@ func TestParse(t *testing.T) {
 				t.Fatalf("NewRepo: %v", err)
 			}
 
-			blobID, err := repo.HashObject(t, typ.TypeBlob, strings.NewReader("content\n"))
+			blobID, err := repo.HashObject(t, typ.Blob, strings.NewReader("content\n"))
 			if err != nil {
 				t.Fatalf("HashObject(blob): %v", err)
 			}
 
 			treeID, err := repo.MkTree(t, []testgit.TreeEntry{
-				{Mode: "100644", Type: typ.TypeBlob, OID: blobID, Name: "file.txt"},
+				{Mode: "100644", Type: typ.Blob, OID: blobID, Name: "file.txt"},
 			})
 			if err != nil {
 				t.Fatalf("MkTree: %v", err)
@@ -64,7 +64,7 @@ func TestParse(t *testing.T) {
 				t.Fatalf("TagAnnotated: %v", err)
 			}
 
-			rawBody, err := repo.CatFile(t, typ.TypeTag, tagID)
+			rawBody, err := repo.CatFile(t, typ.Tag, tagID)
 			if err != nil {
 				t.Fatalf("CatFile: %v", err)
 			}
@@ -78,8 +78,8 @@ func TestParse(t *testing.T) {
 				t.Fatalf("target id = %s, want %s", parsed.TargetID, commitID)
 			}
 
-			if parsed.TargetType != typ.TypeCommit {
-				t.Fatalf("target type = %v, want %v", parsed.TargetType, typ.TypeCommit)
+			if parsed.TargetType != typ.Commit {
+				t.Fatalf("target type = %v, want %v", parsed.TargetType, typ.Commit)
 			}
 
 			if !bytes.Equal(parsed.Name, []byte("v1.2.3")) {
diff --git a/object/tag/roundtrip_test.go b/object/tag/roundtrip_test.go
index 8e754854..c49b3d75 100644
--- a/object/tag/roundtrip_test.go
+++ b/object/tag/roundtrip_test.go
@@ -25,14 +25,14 @@ func TestRoundTrip(t *testing.T) {
 				t.Fatalf("NewRepo: %v", err)
 			}
 
-			blobID, err := repo.HashObject(t, typ.TypeBlob, strings.NewReader("roundtrip\n"))
+			blobID, err := repo.HashObject(t, typ.Blob, strings.NewReader("roundtrip\n"))
 			if err != nil {
 				t.Fatalf("HashObject(blob): %v", err)
 			}
 
 			want := &tag.Tag{
 				TargetID:   blobID,
-				TargetType: typ.TypeBlob,
+				TargetType: typ.Blob,
 				Name:       []byte("roundtrip-tag"),
 				Tagger: signature.Signature{
 					Name:          []byte("Round Trip Tagger"),
@@ -52,7 +52,7 @@ func TestRoundTrip(t *testing.T) {
 				t.Fatalf("AppendWithoutHeader: %v", err)
 			}
 
-			roundTripID, err := repo.HashObject(t, typ.TypeTag, bytes.NewReader(rawBody))
+			roundTripID, err := repo.HashObject(t, typ.Tag, bytes.NewReader(rawBody))
 			if err != nil {
 				t.Fatalf("HashObject(tag): %v", err)
 			}
@@ -65,7 +65,7 @@ func TestRoundTrip(t *testing.T) {
 				t.Fatalf("Fsck: %v", err)
 			}
 
-			gitBody, err := repo.CatFile(t, typ.TypeTag, roundTripID)
+			gitBody, err := repo.CatFile(t, typ.Tag, roundTripID)
 			if err != nil {
 				t.Fatalf("CatFile: %v", err)
 			}
diff --git a/object/tag/type.go b/object/tag/type.go
index 0987a6c1..64883b35 100644
--- a/object/tag/type.go
+++ b/object/tag/type.go
@@ -6,5 +6,5 @@ import "lindenii.org/go/furgit/object/typ"
 func (tag *Tag) ObjectType() typ.Type {
 	_ = tag
 
-	return typ.TypeTag
+	return typ.Tag
 }
diff --git a/object/tree/append.go b/object/tree/append.go
index 9985e668..5fe040f1 100644
--- a/object/tree/append.go
+++ b/object/tree/append.go
@@ -39,7 +39,7 @@ func (tree *Tree) AppendWithHeader(dst []byte) ([]byte, error) {
 		return dst, err
 	}
 
-	dst = header.Append(dst, typ.TypeTree, uint64(len(body)))
+	dst = header.Append(dst, typ.Tree, uint64(len(body)))
 
 	return append(dst, body...), nil
 }
diff --git a/object/tree/append_test.go b/object/tree/append_test.go
index babcd03b..174f50bf 100644
--- a/object/tree/append_test.go
+++ b/object/tree/append_test.go
@@ -29,7 +29,7 @@ func TestAppend(t *testing.T) {
 				t.Fatalf("AppendWithoutHeader: %v", err)
 			}
 
-			treeID, err := repo.HashObject(t, typ.TypeTree, bytes.NewReader(rawBody))
+			treeID, err := repo.HashObject(t, typ.Tree, bytes.NewReader(rawBody))
 			if err != nil {
 				t.Fatalf("HashObject(tree): %v", err)
 			}
diff --git a/object/tree/helpers_test.go b/object/tree/helpers_test.go
index c71f0117..d6cfddb6 100644
--- a/object/tree/helpers_test.go
+++ b/object/tree/helpers_test.go
@@ -15,23 +15,23 @@ import (
 func mixedEntries(tb testing.TB, repo *testgit.Repo) []tree.Entry {
 	tb.Helper()
 
-	blobA, err := repo.HashObject(tb, typ.TypeBlob, strings.NewReader("blob-A\n"))
+	blobA, err := repo.HashObject(tb, typ.Blob, strings.NewReader("blob-A\n"))
 	if err != nil {
 		tb.Fatalf("HashObject(blob-A): %v", err)
 	}
 
-	blobB, err := repo.HashObject(tb, typ.TypeBlob, strings.NewReader("blob-B\n"))
+	blobB, err := repo.HashObject(tb, typ.Blob, strings.NewReader("blob-B\n"))
 	if err != nil {
 		tb.Fatalf("HashObject(blob-B): %v", err)
 	}
 
-	blobC, err := repo.HashObject(tb, typ.TypeBlob, strings.NewReader("blob-C\n"))
+	blobC, err := repo.HashObject(tb, typ.Blob, strings.NewReader("blob-C\n"))
 	if err != nil {
 		tb.Fatalf("HashObject(blob-C): %v", err)
 	}
 
 	subTree, err := repo.MkTree(tb, []testgit.TreeEntry{
-		{Mode: "100644", Type: typ.TypeBlob, OID: blobA, Name: "leaf"},
+		{Mode: "100644", Type: typ.Blob, OID: blobA, Name: "leaf"},
 	})
 	if err != nil {
 		tb.Fatalf("MkTree(subtree): %v", err)
diff --git a/object/tree/mode/details.go b/object/tree/mode/details.go
index 90ead2ed..32ea6768 100644
--- a/object/tree/mode/details.go
+++ b/object/tree/mode/details.go
@@ -19,30 +19,30 @@ var modeTable = map[Mode]modeDetails{
 		valid:         true,
 		isBlobLike:    false,
 		isRegularFile: false,
-		objectType:    typ.TypeTree,
+		objectType:    typ.Tree,
 	},
 	Regular: {
 		valid:         true,
 		isBlobLike:    true,
 		isRegularFile: true,
-		objectType:    typ.TypeBlob,
+		objectType:    typ.Blob,
 	},
 	Executable: {
 		valid:         true,
 		isBlobLike:    true,
 		isRegularFile: true,
-		objectType:    typ.TypeBlob,
+		objectType:    typ.Blob,
 	},
 	Symlink: {
 		valid:         true,
 		isBlobLike:    true,
 		isRegularFile: false,
-		objectType:    typ.TypeBlob,
+		objectType:    typ.Blob,
 	},
 	Gitlink: {
 		valid:         true,
 		isBlobLike:    false,
 		isRegularFile: false,
-		objectType:    typ.TypeCommit,
+		objectType:    typ.Commit,
 	},
 }
diff --git a/object/tree/mode/mode_test.go b/object/tree/mode/mode_test.go
index 0e2cc2aa..2ce6c8ea 100644
--- a/object/tree/mode/mode_test.go
+++ b/object/tree/mode/mode_test.go
@@ -14,12 +14,12 @@ func TestObjectType(t *testing.T) {
 		mode mode.Mode
 		want typ.Type
 	}{
-		{mode: mode.Directory, want: typ.TypeTree},
-		{mode: mode.Regular, want: typ.TypeBlob},
-		{mode: mode.Executable, want: typ.TypeBlob},
-		{mode: mode.Symlink, want: typ.TypeBlob},
-		{mode: mode.Gitlink, want: typ.TypeCommit},
-		{mode: mode.Mode(0), want: typ.TypeUnknown},
+		{mode: mode.Directory, want: typ.Tree},
+		{mode: mode.Regular, want: typ.Blob},
+		{mode: mode.Executable, want: typ.Blob},
+		{mode: mode.Symlink, want: typ.Blob},
+		{mode: mode.Gitlink, want: typ.Commit},
+		{mode: mode.Mode(0), want: typ.Unknown},
 	} {
 		if got := tc.mode.ObjectType(); got != tc.want {
 			t.Fatalf("Mode(%o).ObjectType() = %v, want %v", tc.mode, got, tc.want)
diff --git a/object/tree/mode/ops.go b/object/tree/mode/ops.go
index 149d95db..5f161d0b 100644
--- a/object/tree/mode/ops.go
+++ b/object/tree/mode/ops.go
@@ -32,7 +32,7 @@ func (mode Mode) HasSameType(other Mode) bool {
 
 // ObjectType returns the type of object that an entry with this mode targets.
 //
-// It returns [typ.TypeUnknown] for invalid modes.
+// It returns [typ.Unknown] for invalid modes.
 func (mode Mode) ObjectType() typ.Type {
 	return mode.details().objectType
 }
diff --git a/object/tree/parse_test.go b/object/tree/parse_test.go
index 8d32b136..0f5a8b30 100644
--- a/object/tree/parse_test.go
+++ b/object/tree/parse_test.go
@@ -28,7 +28,7 @@ func TestParse(t *testing.T) {
 				t.Fatalf("MkTree: %v", err)
 			}
 
-			rawBody, err := repo.CatFile(t, typ.TypeTree, treeID)
+			rawBody, err := repo.CatFile(t, typ.Tree, treeID)
 			if err != nil {
 				t.Fatalf("CatFile: %v", err)
 			}
diff --git a/object/tree/roundtrip_test.go b/object/tree/roundtrip_test.go
index 7fdc4140..3e82c79a 100644
--- a/object/tree/roundtrip_test.go
+++ b/object/tree/roundtrip_test.go
@@ -30,7 +30,7 @@ func TestRoundTrip(t *testing.T) {
 				t.Fatalf("AppendWithoutHeader: %v", err)
 			}
 
-			treeID, err := repo.HashObject(t, typ.TypeTree, bytes.NewReader(rawBody))
+			treeID, err := repo.HashObject(t, typ.Tree, bytes.NewReader(rawBody))
 			if err != nil {
 				t.Fatalf("HashObject(tree): %v", err)
 			}
@@ -43,7 +43,7 @@ func TestRoundTrip(t *testing.T) {
 				t.Fatalf("Fsck: %v", err)
 			}
 
-			gitBody, err := repo.CatFile(t, typ.TypeTree, treeID)
+			gitBody, err := repo.CatFile(t, typ.Tree, treeID)
 			if err != nil {
 				t.Fatalf("CatFile: %v", err)
 			}
diff --git a/object/tree/type.go b/object/tree/type.go
index 125e0bcc..aa433e82 100644
--- a/object/tree/type.go
+++ b/object/tree/type.go
@@ -6,5 +6,5 @@ import "lindenii.org/go/furgit/object/typ"
 func (tree *Tree) ObjectType() typ.Type {
 	_ = tree
 
-	return typ.TypeTree
+	return typ.Tree
 }
diff --git a/object/typ/type.go b/object/typ/type.go
index c03ba6d7..b171b324 100644
--- a/object/typ/type.go
+++ b/object/typ/type.go
@@ -4,18 +4,18 @@ package typ
 type Type uint8
 
 const (
-	// TypeUnknown represents an unknown or unset Git object type.
-	TypeUnknown Type = iota
+	// Unknown represents an unknown or unset Git object type.
+	Unknown Type = iota
 
-	// TypeBlob represents a Git blob.
-	TypeBlob
+	// Blob represents a Git blob.
+	Blob
 
-	// TypeTree represents a Git tree.
-	TypeTree
+	// Tree represents a Git tree.
+	Tree
 
-	// TypeCommit represents a Git commit.
-	TypeCommit
+	// Commit represents a Git commit.
+	Commit
 
-	// TypeTag represents a Git tag.
-	TypeTag
+	// Tag represents a Git tag.
+	Tag
 )
diff --git a/object/typ/type_details.go b/object/typ/type_details.go
index 83938765..5e2e370b 100644
--- a/object/typ/type_details.go
+++ b/object/typ/type_details.go
@@ -10,16 +10,16 @@ func (ty Type) details() typeDetails {
 
 //nolint:gochecknoglobals
 var typeTable = [...]typeDetails{
-	TypeCommit: {name: "commit"},
-	TypeTree:   {name: "tree"},
-	TypeBlob:   {name: "blob"},
-	TypeTag:    {name: "tag"},
+	Commit: {name: "commit"},
+	Tree:   {name: "tree"},
+	Blob:   {name: "blob"},
+	Tag:    {name: "tag"},
 }
 
 //nolint:gochecknoglobals
 var typeByName = map[string]Type{
-	typeTable[TypeCommit].name: TypeCommit,
-	typeTable[TypeTree].name:   TypeTree,
-	typeTable[TypeBlob].name:   TypeBlob,
-	typeTable[TypeTag].name:    TypeTag,
+	typeTable[Commit].name: Commit,
+	typeTable[Tree].name:   Tree,
+	typeTable[Blob].name:   Blob,
+	typeTable[Tag].name:    Tag,
 }