diff --git a/pw_kvs/alignment_test.cc b/pw_kvs/alignment_test.cc
index 0f3dc89..536de87 100644
--- a/pw_kvs/alignment_test.cc
+++ b/pw_kvs/alignment_test.cc
@@ -141,26 +141,26 @@
   AlignedWriterBuffer<32> writer(kAlignment, check_against_data);
 
   // Write values smaller than the alignment.
-  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(0, 1)).status());
-  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(1, 9)).status());
+  EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(0, 1)).status());
+  EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(1, 9)).status());
 
   // Write values larger than the alignment but smaller than the buffer.
-  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(10, 11)).status());
+  EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(10, 11)).status());
 
   // Exactly fill the remainder of the buffer.
-  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(21, 11)).status());
+  EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(21, 11)).status());
 
   // Fill the buffer more than once.
-  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(32, 66)).status());
+  EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(32, 66)).status());
 
   // Write nothing.
-  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(98, 0)).status());
+  EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(98, 0)).status());
 
   // Write the remaining data.
-  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(98, 2)).status());
+  EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(98, 2)).status());
 
   auto result = writer.Flush();
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(kData.size(), result.size());
 }
 
@@ -202,7 +202,7 @@
         ADD_FAILURE();
         break;
     }
-    return StatusWithSize(Status::UNKNOWN, data.size());
+    return StatusWithSize::Unknown(data.size());
   }
 };
 
@@ -213,7 +213,7 @@
     AlignedWriterBuffer<4> writer(3, output);
     writer.Write(std::as_bytes(std::span("Everything is fine.")));
     output.state = OutputWithErrorInjection::kBreakOnNext;
-    EXPECT_EQ(Status::UNKNOWN,
+    EXPECT_EQ(Status::Unknown(),
               writer.Write(std::as_bytes(std::span("No more writes, okay?")))
                   .status());
     writer.Flush();
@@ -222,7 +222,7 @@
 
 TEST(AlignedWriter, Write_ReturnsTotalBytesWritten) {
   static Status return_status;
-  return_status = Status::OK;
+  return_status = Status::Ok();
 
   OutputToFunction output([](std::span<const byte> data) {
     return StatusWithSize(return_status, data.size());
@@ -232,17 +232,17 @@
 
   StatusWithSize result =
       writer.Write(std::as_bytes(std::span("12345678901"sv)));
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(0u, result.size());  // No writes; haven't filled buffer.
 
   result = writer.Write(std::as_bytes(std::span("2345678901"sv)));
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(20u, result.size());
 
-  return_status = Status::PERMISSION_DENIED;
+  return_status = Status::PermissionDenied();
 
   result = writer.Write(std::as_bytes(std::span("2345678901234567890"sv)));
-  EXPECT_EQ(Status::PERMISSION_DENIED, result.status());
+  EXPECT_EQ(Status::PermissionDenied(), result.status());
   EXPECT_EQ(40u, result.size());
 }
 
@@ -252,17 +252,17 @@
 
   AlignedWriterBuffer<4> writer(2, output);
 
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(Status::Ok(),
             writer.Write(std::as_bytes(std::span("12345678901"sv))).status());
 
   StatusWithSize result = writer.Flush();
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(12u, result.size());
 }
 
 TEST(AlignedWriter, Flush_Error_ReturnsTotalBytesWritten) {
   OutputToFunction output([](std::span<const byte> data) {
-    return StatusWithSize(Status::ABORTED, data.size());
+    return StatusWithSize::Aborted(data.size());
   });
 
   AlignedWriterBuffer<20> writer(10, output);
@@ -270,7 +270,7 @@
   EXPECT_EQ(0u, writer.Write(std::as_bytes(std::span("12345678901"sv))).size());
 
   StatusWithSize result = writer.Flush();
-  EXPECT_EQ(Status::ABORTED, result.status());
+  EXPECT_EQ(Status::Aborted(), result.status());
   EXPECT_EQ(20u, result.size());
 }
 
@@ -284,12 +284,12 @@
     EXPECT_LE(index_ + data.size(), kBytes.size());
 
     if (index_ + data.size() > kBytes.size()) {
-      return StatusWithSize::INTERNAL;
+      return StatusWithSize::Internal();
     }
 
     // Check if reading from the index that was programmed to cause an error.
     if (index_ <= break_on_index_ && break_on_index_ <= index_ + data.size()) {
-      return StatusWithSize::ABORTED;
+      return StatusWithSize::Aborted();
     }
 
     std::memcpy(data.data(), kBytes.data(), data.size());
@@ -306,11 +306,11 @@
 
   InputWithErrorInjection input;
   StatusWithSize result = writer.Write(input, kData.size());
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_LE(result.size(), kData.size());  // May not have written it all yet.
 
   result = writer.Flush();
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(kData.size(), result.size());
 }
 
@@ -321,7 +321,7 @@
   input.BreakOnIndex(kAlignment + 2);
 
   StatusWithSize result = writer.Write(input, kData.size());
-  EXPECT_EQ(Status::ABORTED, result.status());
+  EXPECT_EQ(Status::Aborted(), result.status());
   EXPECT_LE(result.size(), kAlignment);  // Wrote the first chunk, nothing more.
 }
 
@@ -333,7 +333,7 @@
   output.state = OutputWithErrorInjection::kBreakOnNext;
 
   StatusWithSize result = writer.Write(input, kData.size());
-  EXPECT_EQ(Status::UNKNOWN, result.status());
+  EXPECT_EQ(Status::Unknown(), result.status());
   EXPECT_EQ(3u, result.size());  // Attempted to write 3 bytes.
 }
 
diff --git a/pw_kvs/checksum.cc b/pw_kvs/checksum.cc
index 0a885f7..08f59b8 100644
--- a/pw_kvs/checksum.cc
+++ b/pw_kvs/checksum.cc
@@ -22,12 +22,12 @@
 
 Status ChecksumAlgorithm::Verify(std::span<const byte> checksum) const {
   if (checksum.size() < size_bytes()) {
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
   if (std::memcmp(state_.data(), checksum.data(), size_bytes()) != 0) {
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 }  // namespace pw::kvs
diff --git a/pw_kvs/checksum_test.cc b/pw_kvs/checksum_test.cc
index 0db5ed2..4fffae0 100644
--- a/pw_kvs/checksum_test.cc
+++ b/pw_kvs/checksum_test.cc
@@ -32,19 +32,20 @@
   ChecksumAlgorithm& algo = crc16_algo;
 
   algo.Update(kString.data(), kString.size());
-  EXPECT_EQ(Status::OK, algo.Verify(std::as_bytes(std::span(&kStringCrc, 1))));
+  EXPECT_EQ(Status::Ok(),
+            algo.Verify(std::as_bytes(std::span(&kStringCrc, 1))));
 }
 
 TEST(Checksum, Verify_Failure) {
   ChecksumCrc16 algo;
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             algo.Verify(std::as_bytes(std::span(kString.data(), 2))));
 }
 
 TEST(Checksum, Verify_InvalidSize) {
   ChecksumCrc16 algo;
-  EXPECT_EQ(Status::INVALID_ARGUMENT, algo.Verify({}));
-  EXPECT_EQ(Status::INVALID_ARGUMENT,
+  EXPECT_EQ(Status::InvalidArgument(), algo.Verify({}));
+  EXPECT_EQ(Status::InvalidArgument(),
             algo.Verify(std::as_bytes(std::span(kString.substr(0, 1)))));
 }
 
@@ -55,7 +56,7 @@
 
   algo.Update(std::as_bytes(std::span(kString)));
 
-  EXPECT_EQ(Status::OK, algo.Verify(crc));
+  EXPECT_EQ(Status::Ok(), algo.Verify(crc));
 }
 
 TEST(Checksum, Reset) {
@@ -71,20 +72,20 @@
 TEST(IgnoreChecksum, NeverUpdate_VerifyWithoutData) {
   IgnoreChecksum checksum;
 
-  EXPECT_EQ(Status::OK, checksum.Verify({}));
+  EXPECT_EQ(Status::Ok(), checksum.Verify({}));
 }
 
 TEST(IgnoreChecksum, NeverUpdate_VerifyWithData) {
   IgnoreChecksum checksum;
 
-  EXPECT_EQ(Status::OK, checksum.Verify(std::as_bytes(std::span(kString))));
+  EXPECT_EQ(Status::Ok(), checksum.Verify(std::as_bytes(std::span(kString))));
 }
 
 TEST(IgnoreChecksum, AfterUpdate_Verify) {
   IgnoreChecksum checksum;
 
   checksum.Update(std::as_bytes(std::span(kString)));
-  EXPECT_EQ(Status::OK, checksum.Verify({}));
+  EXPECT_EQ(Status::Ok(), checksum.Verify({}));
 }
 
 constexpr size_t kAlignment = 10;
@@ -143,7 +144,7 @@
   EXPECT_EQ(std::string_view(reinterpret_cast<const char*>(state.data()),
                              state.size()),
             kData);
-  EXPECT_EQ(Status::OK, checksum.Verify(kBytes));
+  EXPECT_EQ(Status::Ok(), checksum.Verify(kBytes));
 }
 
 }  // namespace
diff --git a/pw_kvs/entry.cc b/pw_kvs/entry.cc
index cfa9e76..0fa68da 100644
--- a/pw_kvs/entry.cc
+++ b/pw_kvs/entry.cc
@@ -43,10 +43,10 @@
   PW_TRY(partition.Read(address, sizeof(header), &header));
 
   if (partition.AppearsErased(std::as_bytes(std::span(&header.magic, 1)))) {
-    return Status::NOT_FOUND;
+    return Status::NotFound();
   }
   if (header.key_length_bytes > kMaxKeyLength) {
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
   const EntryFormat* format = formats.Find(header.magic);
@@ -54,11 +54,11 @@
     PW_LOG_ERROR("Found corrupt magic: %" PRIx32 " at address %u",
                  header.magic,
                  unsigned(address));
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
   *entry = Entry(&partition, address, *format, header);
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status Entry::ReadKey(FlashPartition& partition,
@@ -66,7 +66,7 @@
                       size_t key_length,
                       char* key) {
   if (key_length == 0u || key_length > kMaxKeyLength) {
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
   return partition.Read(address + sizeof(EntryHeader), key_length, key)
@@ -145,7 +145,7 @@
 StatusWithSize Entry::ReadValue(std::span<byte> buffer,
                                 size_t offset_bytes) const {
   if (offset_bytes > value_size()) {
-    return StatusWithSize::OUT_OF_RANGE;
+    return StatusWithSize::OutOfRange();
   }
 
   const size_t remaining_bytes = value_size() - offset_bytes;
@@ -157,14 +157,14 @@
   PW_TRY_WITH_SIZE(result);
 
   if (read_size != remaining_bytes) {
-    return StatusWithSize(Status::RESOURCE_EXHAUSTED, read_size);
+    return StatusWithSize::ResourceExhausted(read_size);
   }
   return StatusWithSize(read_size);
 }
 
 Status Entry::ValueMatches(std::span<const std::byte> value) const {
   if (value_size() != value.size_bytes()) {
-    return Status::NOT_FOUND;
+    return Status::NotFound();
   }
 
   Address address = address_ + sizeof(EntryHeader) + key_length();
@@ -177,20 +177,20 @@
     PW_TRY(partition_->Read(address, std::span(buffer).first(read_size)));
 
     if (std::memcmp(buffer.data(), value_ptr, read_size) != 0) {
-      return Status::NOT_FOUND;
+      return Status::NotFound();
     }
 
     address += read_size;
     value_ptr += read_size;
   }
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status Entry::VerifyChecksum(string_view key,
                              std::span<const byte> value) const {
   if (checksum_algo_ == nullptr) {
-    return header_.checksum == 0 ? Status::OK : Status::DATA_LOSS;
+    return header_.checksum == 0 ? Status::Ok() : Status::DataLoss();
   }
   CalculateChecksum(key, value);
   return checksum_algo_->Verify(checksum_bytes());
@@ -216,11 +216,11 @@
     PW_LOG_ERROR("Expected checksum 0x%08" PRIx32 ", found 0x%08" PRIx32,
                  header_.checksum,
                  header_to_verify.checksum);
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
   if (checksum_algo_ == nullptr) {
-    return header_.checksum == 0 ? Status::OK : Status::DATA_LOSS;
+    return header_.checksum == 0 ? Status::Ok() : Status::DataLoss();
   }
 
   // The checksum is calculated as if the header's checksum field were 0.
@@ -281,7 +281,7 @@
   header_.checksum = 0;
 
   if (checksum_algo_ == nullptr) {
-    return Status::OK;
+    return Status::Ok();
   }
 
   checksum_algo_->Reset();
@@ -307,7 +307,7 @@
   std::memcpy(&header_.checksum,
               checksum.data(),
               std::min(checksum.size(), sizeof(header_.checksum)));
-  return Status::OK;
+  return Status::Ok();
 }
 
 void Entry::AddPaddingBytesToChecksum() const {
diff --git a/pw_kvs/entry_cache.cc b/pw_kvs/entry_cache.cc
index c6d58a8..b6245a4 100644
--- a/pw_kvs/entry_cache.cc
+++ b/pw_kvs/entry_cache.cc
@@ -103,18 +103,18 @@
 
       if (!key_found) {
         PW_LOG_ERROR("No valid entries for key. Data has been lost!");
-        return StatusWithSize(Status::DATA_LOSS, error_val);
+        return StatusWithSize::DataLoss(error_val);
       } else if (key == read_key) {
         PW_LOG_DEBUG("Found match for key hash 0x%08" PRIx32, hash);
         *metadata = EntryMetadata(descriptors_[i], addresses(i));
-        return StatusWithSize(Status::OK, error_val);
+        return StatusWithSize::Ok(error_val);
       } else {
         PW_LOG_WARN("Found key hash collision for 0x%08" PRIx32, hash);
-        return StatusWithSize(Status::ALREADY_EXISTS, error_val);
+        return StatusWithSize::AlreadyExists(error_val);
       }
     }
   }
-  return StatusWithSize::NOT_FOUND;
+  return StatusWithSize::NotFound();
 }
 
 EntryMetadata EntryCache::AddNew(const KeyDescriptor& descriptor,
@@ -139,17 +139,17 @@
   // Write a new entry if there is room.
   if (index == -1) {
     if (full()) {
-      return Status::RESOURCE_EXHAUSTED;
+      return Status::ResourceExhausted();
     }
     AddNew(descriptor, address);
-    return Status::OK;
+    return Status::Ok();
   }
 
   // Existing entry is old; replace the existing entry with the new one.
   if (descriptor.transaction_id > descriptors_[index].transaction_id) {
     descriptors_[index] = descriptor;
     ResetAddresses(index, address);
-    return Status::OK;
+    return Status::Ok();
   }
 
   // If the entries have a duplicate transaction ID, add the new (redundant)
@@ -160,7 +160,7 @@
                    " with transaction ID %" PRIu32 " has non-matching hash",
                    descriptor.key_hash,
                    descriptor.transaction_id);
-      return Status::DATA_LOSS;
+      return Status::DataLoss();
     }
 
     // Verify that this entry is not in the same sector as an existing copy of
@@ -169,7 +169,7 @@
       if (existing_address / sector_size_bytes == address / sector_size_bytes) {
         PW_LOG_DEBUG("Multiple Redundant entries in same sector %u",
                      unsigned(address / sector_size_bytes));
-        return Status::DATA_LOSS;
+        return Status::DataLoss();
       }
     }
 
@@ -177,7 +177,7 @@
   } else {
     PW_LOG_DEBUG("Found stale entry when appending; ignoring");
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 size_t EntryCache::present_entries() const {
diff --git a/pw_kvs/entry_cache_test.cc b/pw_kvs/entry_cache_test.cc
index 2bdedf4..7d6a25f 100644
--- a/pw_kvs/entry_cache_test.cc
+++ b/pw_kvs/entry_cache_test.cc
@@ -83,7 +83,7 @@
 }
 
 TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_NewEntry) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 2000));
 
   EXPECT_EQ(1u, entries_.present_entries());
@@ -98,13 +98,13 @@
 TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_NewEntry_Full) {
   for (uint32_t i = 0; i < kMaxEntries; ++i) {
     ASSERT_EQ(  // Fill up the cache
-        Status::OK,
+        Status::Ok(),
         entries_.AddNewOrUpdateExisting({i, i, EntryState::kValid}, i, 1));
   }
   ASSERT_EQ(kMaxEntries, entries_.total_entries());
   ASSERT_TRUE(entries_.full());
 
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED,
+  EXPECT_EQ(Status::ResourceExhausted(),
             entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 1));
   EXPECT_EQ(kMaxEntries, entries_.total_entries());
 }
@@ -113,7 +113,7 @@
   KeyDescriptor kd = kDescriptor;
   kd.transaction_id += 3;
 
-  ASSERT_EQ(Status::OK, entries_.AddNewOrUpdateExisting(kd, 3210, 2000));
+  ASSERT_EQ(Status::Ok(), entries_.AddNewOrUpdateExisting(kd, 3210, 2000));
 
   EXPECT_EQ(1u, entries_.present_entries());
 
@@ -125,15 +125,15 @@
 }
 
 TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_AddDuplicateEntry) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 2000));
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             entries_.AddNewOrUpdateExisting(kDescriptor, 3000, 2000));
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             entries_.AddNewOrUpdateExisting(kDescriptor, 7000, 2000));
 
   // Duplicates beyond the redundancy are ignored.
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             entries_.AddNewOrUpdateExisting(kDescriptor, 9000, 2000));
 
   EXPECT_EQ(1u, entries_.present_entries());
@@ -150,9 +150,9 @@
 }
 
 TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_AddDuplicateEntryInSameSector) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 1000));
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             entries_.AddNewOrUpdateExisting(kDescriptor, 1950, 1000));
 
   EXPECT_EQ(1u, entries_.present_entries());
@@ -320,7 +320,7 @@
   StatusWithSize result =
       entries_.Find(partition_, sectors_, format_, kTheKey, &metadata);
 
-  ASSERT_EQ(Status::OK, result.status());
+  ASSERT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(0u, result.size());
   EXPECT_EQ(Hash(kTheKey), metadata.hash());
   EXPECT_EQ(EntryState::kValid, metadata.state());
@@ -330,14 +330,14 @@
 TEST_F(InitializedEntryCache, Find_PresentEntryWithSingleReadError) {
   // Inject 2 read errors so that the initial key read and the follow-up full
   // read of the first entry fail.
-  flash_.InjectReadError(FlashError::Unconditional(Status::INTERNAL, 2));
+  flash_.InjectReadError(FlashError::Unconditional(Status::Internal(), 2));
 
   EntryMetadata metadata;
 
   StatusWithSize result =
       entries_.Find(partition_, sectors_, format_, kTheKey, &metadata);
 
-  ASSERT_EQ(Status::OK, result.status());
+  ASSERT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(1u, result.size());
   EXPECT_EQ(Hash(kTheKey), metadata.hash());
   EXPECT_EQ(EntryState::kValid, metadata.state());
@@ -345,14 +345,14 @@
 }
 
 TEST_F(InitializedEntryCache, Find_PresentEntryWithMultiReadError) {
-  flash_.InjectReadError(FlashError::Unconditional(Status::INTERNAL, 4));
+  flash_.InjectReadError(FlashError::Unconditional(Status::Internal(), 4));
 
   EntryMetadata metadata;
 
   StatusWithSize result =
       entries_.Find(partition_, sectors_, format_, kTheKey, &metadata);
 
-  ASSERT_EQ(Status::DATA_LOSS, result.status());
+  ASSERT_EQ(Status::DataLoss(), result.status());
   EXPECT_EQ(1u, result.size());
   CheckForCorruptSectors(&sectors_.FromAddress(0),
                          &sectors_.FromAddress(kSize1));
@@ -364,7 +364,7 @@
   StatusWithSize result =
       entries_.Find(partition_, sectors_, format_, "delorted", &metadata);
 
-  ASSERT_EQ(Status::OK, result.status());
+  ASSERT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(0u, result.size());
   EXPECT_EQ(Hash("delorted"), metadata.hash());
   EXPECT_EQ(EntryState::kDeleted, metadata.state());
@@ -377,7 +377,7 @@
   StatusWithSize result =
       entries_.Find(partition_, sectors_, format_, "3.141", &metadata);
 
-  ASSERT_EQ(Status::NOT_FOUND, result.status());
+  ASSERT_EQ(Status::NotFound(), result.status());
   EXPECT_EQ(0u, result.size());
   CheckForCorruptSectors();
 }
@@ -387,7 +387,7 @@
 
   StatusWithSize result =
       entries_.Find(partition_, sectors_, format_, kCollision2, &metadata);
-  EXPECT_EQ(Status::ALREADY_EXISTS, result.status());
+  EXPECT_EQ(Status::AlreadyExists(), result.status());
   EXPECT_EQ(0u, result.size());
   CheckForCorruptSectors();
 }
diff --git a/pw_kvs/entry_test.cc b/pw_kvs/entry_test.cc
index 411f241..8ac1d1a 100644
--- a/pw_kvs/entry_test.cc
+++ b/pw_kvs/entry_test.cc
@@ -116,7 +116,7 @@
 class ValidEntryInFlash : public ::testing::Test {
  protected:
   ValidEntryInFlash() : flash_(kEntry1), partition_(&flash_) {
-    EXPECT_EQ(Status::OK, Entry::Read(partition_, 0, kFormats, &entry_));
+    EXPECT_EQ(Status::Ok(), Entry::Read(partition_, 0, kFormats, &entry_));
   }
 
   FakeFlashMemoryBuffer<1024, 4> flash_;
@@ -125,8 +125,8 @@
 };
 
 TEST_F(ValidEntryInFlash, PassesChecksumVerification) {
-  EXPECT_EQ(Status::OK, entry_.VerifyChecksumInFlash());
-  EXPECT_EQ(Status::OK, entry_.VerifyChecksum("key45", kValue1));
+  EXPECT_EQ(Status::Ok(), entry_.VerifyChecksumInFlash());
+  EXPECT_EQ(Status::Ok(), entry_.VerifyChecksum("key45", kValue1));
 }
 
 TEST_F(ValidEntryInFlash, HeaderContents) {
@@ -141,7 +141,7 @@
   Entry::KeyBuffer key = {};
   auto result = entry_.ReadKey(key);
 
-  ASSERT_EQ(Status::OK, result.status());
+  ASSERT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(result.size(), entry_.key_length());
   EXPECT_STREQ(key.data(), "key45");
 }
@@ -150,7 +150,7 @@
   char value[32] = {};
   auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)));
 
-  ASSERT_EQ(Status::OK, result.status());
+  ASSERT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(result.size(), entry_.value_size());
   EXPECT_STREQ(value, "VALUE!");
 }
@@ -159,7 +159,7 @@
   char value[3] = {};
   auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)));
 
-  ASSERT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
+  ASSERT_EQ(Status::ResourceExhausted(), result.status());
   EXPECT_EQ(3u, result.size());
   EXPECT_EQ(value[0], 'V');
   EXPECT_EQ(value[1], 'A');
@@ -170,7 +170,7 @@
   char value[3] = {};
   auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 3);
 
-  ASSERT_EQ(Status::OK, result.status());
+  ASSERT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(3u, result.size());
   EXPECT_EQ(value[0], 'U');
   EXPECT_EQ(value[1], 'E');
@@ -181,7 +181,7 @@
   char value[1] = {};
   auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 4);
 
-  ASSERT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
+  ASSERT_EQ(Status::ResourceExhausted(), result.status());
   EXPECT_EQ(1u, result.size());
   EXPECT_EQ(value[0], 'E');
 }
@@ -190,7 +190,7 @@
   char value[16] = {'?'};
   auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 6);
 
-  ASSERT_EQ(Status::OK, result.status());
+  ASSERT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(0u, result.size());
   EXPECT_EQ(value[0], '?');
 }
@@ -199,7 +199,7 @@
   char value[16] = {};
   auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 7);
 
-  EXPECT_EQ(Status::OUT_OF_RANGE, result.status());
+  EXPECT_EQ(Status::OutOfRange(), result.status());
   EXPECT_EQ(0u, result.size());
 }
 
@@ -211,7 +211,7 @@
       partition, 64, kFormatWithChecksum, "key45", kValue1, kTransactionId1);
 
   auto result = entry.Write("key45", kValue1);
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(32u, result.size());
   EXPECT_EQ(std::memcmp(&flash.buffer()[64], kEntry1.data(), kEntry1.size()),
             0);
@@ -233,7 +233,7 @@
  protected:
   TombstoneEntryInFlash()
       : flash_(bytes::Concat(kHeader2, kKeyAndPadding2)), partition_(&flash_) {
-    EXPECT_EQ(Status::OK, Entry::Read(partition_, 0, kFormats, &entry_));
+    EXPECT_EQ(Status::Ok(), Entry::Read(partition_, 0, kFormats, &entry_));
   }
 
   FakeFlashMemoryBuffer<1024, 4> flash_;
@@ -242,8 +242,8 @@
 };
 
 TEST_F(TombstoneEntryInFlash, PassesChecksumVerification) {
-  EXPECT_EQ(Status::OK, entry_.VerifyChecksumInFlash());
-  EXPECT_EQ(Status::OK, entry_.VerifyChecksum("K", {}));
+  EXPECT_EQ(Status::Ok(), entry_.VerifyChecksumInFlash());
+  EXPECT_EQ(Status::Ok(), entry_.VerifyChecksum("K", {}));
 }
 
 TEST_F(TombstoneEntryInFlash, HeaderContents) {
@@ -258,7 +258,7 @@
   Entry::KeyBuffer key = {};
   auto result = entry_.ReadKey(key);
 
-  ASSERT_EQ(Status::OK, result.status());
+  ASSERT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(result.size(), entry_.key_length());
   EXPECT_STREQ(key.data(), "K");
 }
@@ -267,7 +267,7 @@
   char value[32] = {};
   auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)));
 
-  ASSERT_EQ(Status::OK, result.status());
+  ASSERT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(0u, result.size());
 }
 
@@ -280,7 +280,7 @@
       Entry::Tombstone(partition, 16, kFormatWithChecksum, "K", 0x03020100);
 
   auto result = entry.Write("K", {});
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(32u, result.size());
   EXPECT_EQ(std::memcmp(&flash.buffer()[16],
                         bytes::Concat(kHeader2, kKeyAndPadding2).data(),
@@ -296,15 +296,15 @@
   const EntryFormat format{kMagicWithChecksum, nullptr};
   const internal::EntryFormats formats(format);
 
-  ASSERT_EQ(Status::OK, Entry::Read(partition, 0, formats, &entry));
+  ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, formats, &entry));
 
-  EXPECT_EQ(Status::DATA_LOSS, entry.VerifyChecksumInFlash());
-  EXPECT_EQ(Status::DATA_LOSS, entry.VerifyChecksum({}, {}));
+  EXPECT_EQ(Status::DataLoss(), entry.VerifyChecksumInFlash());
+  EXPECT_EQ(Status::DataLoss(), entry.VerifyChecksum({}, {}));
 
   std::memset(&flash.buffer()[4], 0, 4);  // set the checksum field to 0
-  ASSERT_EQ(Status::OK, Entry::Read(partition, 0, formats, &entry));
-  EXPECT_EQ(Status::OK, entry.VerifyChecksumInFlash());
-  EXPECT_EQ(Status::OK, entry.VerifyChecksum({}, {}));
+  ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, formats, &entry));
+  EXPECT_EQ(Status::Ok(), entry.VerifyChecksumInFlash());
+  EXPECT_EQ(Status::Ok(), entry.VerifyChecksum({}, {}));
 }
 
 TEST(Entry, Checksum_ChecksPadding) {
@@ -312,20 +312,20 @@
       bytes::Concat(kHeader1, kKey1, kValue1, bytes::String("\0\0\0\0\1")));
   FlashPartition partition(&flash);
   Entry entry;
-  ASSERT_EQ(Status::OK, Entry::Read(partition, 0, kFormats, &entry));
+  ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, kFormats, &entry));
 
   // Last byte in padding is a 1; should fail.
-  EXPECT_EQ(Status::DATA_LOSS, entry.VerifyChecksumInFlash());
+  EXPECT_EQ(Status::DataLoss(), entry.VerifyChecksumInFlash());
 
   // The in-memory verification fills in 0s for the padding.
-  EXPECT_EQ(Status::OK, entry.VerifyChecksum("key45", kValue1));
+  EXPECT_EQ(Status::Ok(), entry.VerifyChecksum("key45", kValue1));
 
   flash.buffer()[kEntry1.size() - 1] = byte{0};
-  EXPECT_EQ(Status::OK, entry.VerifyChecksumInFlash());
+  EXPECT_EQ(Status::Ok(), entry.VerifyChecksumInFlash());
 }
 
 TEST_F(ValidEntryInFlash, Update_SameFormat_TransactionIdIsUpdated) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             entry_.Update(kFormatWithChecksum, kTransactionId1 + 3));
 
   EXPECT_EQ(kFormatWithChecksum.magic, entry_.magic());
@@ -336,7 +336,7 @@
 
 TEST_F(ValidEntryInFlash,
        Update_DifferentFormat_MagicAndTransactionIdAreUpdated) {
-  ASSERT_EQ(Status::OK, entry_.Update(kFormat, kTransactionId1 + 6));
+  ASSERT_EQ(Status::Ok(), entry_.Update(kFormat, kTransactionId1 + 6));
 
   EXPECT_EQ(kFormat.magic, entry_.magic());
   EXPECT_EQ(0u, entry_.address());
@@ -345,9 +345,9 @@
 }
 
 TEST_F(ValidEntryInFlash, Update_ReadError_WithChecksumIsError) {
-  flash_.InjectReadError(FlashError::Unconditional(Status::ABORTED));
+  flash_.InjectReadError(FlashError::Unconditional(Status::Aborted()));
 
-  EXPECT_EQ(Status::ABORTED,
+  EXPECT_EQ(Status::Aborted(),
             entry_.Update(kFormatWithChecksum, kTransactionId1 + 1));
 }
 
@@ -357,15 +357,16 @@
                                         .checksum = nullptr};
 
 TEST_F(ValidEntryInFlash, Update_ReadError_NoChecksumIsOkay) {
-  flash_.InjectReadError(FlashError::Unconditional(Status::ABORTED));
+  flash_.InjectReadError(FlashError::Unconditional(Status::Aborted()));
 
-  EXPECT_EQ(Status::OK, entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
+  EXPECT_EQ(Status::Ok(),
+            entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
 }
 
 TEST_F(ValidEntryInFlash, Copy) {
   auto result = entry_.Copy(123);
 
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(entry_.size(), result.size());
   EXPECT_EQ(0,
             std::memcmp(
@@ -373,9 +374,9 @@
 }
 
 TEST_F(ValidEntryInFlash, Copy_ReadError) {
-  flash_.InjectReadError(FlashError::Unconditional(Status::UNIMPLEMENTED));
+  flash_.InjectReadError(FlashError::Unconditional(Status::Unimplemented()));
   auto result = entry_.Copy(kEntry1.size());
-  EXPECT_EQ(Status::UNIMPLEMENTED, result.status());
+  EXPECT_EQ(Status::Unimplemented(), result.status());
   EXPECT_EQ(0u, result.size());
 }
 
@@ -435,10 +436,10 @@
 
 TEST_F(ValidEntryInFlash, UpdateAndCopy_DifferentFormatSmallerAlignment) {
   // Uses 16-bit alignment, smaller than the original entry's alignment.
-  ASSERT_EQ(Status::OK, entry_.Update(kFormatWithSum, kTransactionId1 + 1));
+  ASSERT_EQ(Status::Ok(), entry_.Update(kFormatWithSum, kTransactionId1 + 1));
 
   StatusWithSize result = entry_.Copy(kEntry1.size());
-  ASSERT_EQ(Status::OK, result.status());
+  ASSERT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(kEntry1.size(), result.size());
 
   constexpr auto new_data = MakeNewFormatWithSumEntry<16>();
@@ -449,9 +450,9 @@
       std::memcmp(
           &flash_.buffer()[kEntry1.size()], new_data.data(), new_data.size()));
   Entry new_entry;
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             Entry::Read(partition_, 32, kFormatsWithSum, &new_entry));
-  EXPECT_EQ(Status::OK, new_entry.VerifyChecksumInFlash());
+  EXPECT_EQ(Status::Ok(), new_entry.VerifyChecksumInFlash());
   EXPECT_EQ(kFormatWithSum.magic, new_entry.magic());
   EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id());
 }
@@ -461,12 +462,12 @@
   FakeFlashMemoryBuffer<1024, 4> flash(kEntry1);
   FlashPartition partition(&flash, 0, 4, 32);
   Entry entry;
-  ASSERT_EQ(Status::OK, Entry::Read(partition, 0, kFormats, &entry));
+  ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, kFormats, &entry));
 
-  ASSERT_EQ(Status::OK, entry.Update(kFormatWithSum, kTransactionId1 + 1));
+  ASSERT_EQ(Status::Ok(), entry.Update(kFormatWithSum, kTransactionId1 + 1));
 
   StatusWithSize result = entry.Copy(32);
-  ASSERT_EQ(Status::OK, result.status());
+  ASSERT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(AlignUp(kEntry1.size(), 32), result.size());
 
   constexpr auto new_data = MakeNewFormatWithSumEntry<32>();
@@ -476,9 +477,9 @@
             std::memcmp(&flash.buffer()[32], new_data.data(), new_data.size()));
 
   Entry new_entry;
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             Entry::Read(partition, 32, kFormatsWithSum, &new_entry));
-  EXPECT_EQ(Status::OK, new_entry.VerifyChecksumInFlash());
+  EXPECT_EQ(Status::Ok(), new_entry.VerifyChecksumInFlash());
   EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id());
 }
 
@@ -487,12 +488,12 @@
   FakeFlashMemoryBuffer<1024, 4> flash(kEntry1);
   FlashPartition partition(&flash, 0, 4, 64);
   Entry entry;
-  ASSERT_EQ(Status::OK, Entry::Read(partition, 0, kFormats, &entry));
+  ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, kFormats, &entry));
 
-  ASSERT_EQ(Status::OK, entry.Update(kFormatWithSum, kTransactionId1 + 1));
+  ASSERT_EQ(Status::Ok(), entry.Update(kFormatWithSum, kTransactionId1 + 1));
 
   StatusWithSize result = entry.Copy(64);
-  ASSERT_EQ(Status::OK, result.status());
+  ASSERT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(AlignUp(kEntry1.size(), 64), result.size());
 
   constexpr auto new_data = MakeNewFormatWithSumEntry<64>();
@@ -502,9 +503,9 @@
             std::memcmp(&flash.buffer()[64], new_data.data(), new_data.size()));
 
   Entry new_entry;
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             Entry::Read(partition, 64, kFormatsWithSum, &new_entry));
-  EXPECT_EQ(Status::OK, new_entry.VerifyChecksumInFlash());
+  EXPECT_EQ(Status::Ok(), new_entry.VerifyChecksumInFlash());
   EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id());
 }
 
@@ -513,10 +514,10 @@
   // readable 4 bytes. See pw_kvs/format.h for more information.
   constexpr EntryFormat no_checksum{.magic = 0x43fae18f, .checksum = nullptr};
 
-  ASSERT_EQ(Status::OK, entry_.Update(no_checksum, kTransactionId1 + 1));
+  ASSERT_EQ(Status::Ok(), entry_.Update(no_checksum, kTransactionId1 + 1));
 
   auto result = entry_.Copy(kEntry1.size());
-  ASSERT_EQ(Status::OK, result.status());
+  ASSERT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(kEntry1.size(), result.size());
 
   constexpr auto kNewHeader1 =
@@ -536,23 +537,23 @@
 }
 
 TEST_F(ValidEntryInFlash, UpdateAndCopyMultple_DifferentFormat) {
-  ASSERT_EQ(Status::OK, entry_.Update(kFormatWithSum, kTransactionId1 + 6));
+  ASSERT_EQ(Status::Ok(), entry_.Update(kFormatWithSum, kTransactionId1 + 6));
 
   FlashPartition::Address new_address = entry_.size();
 
   for (int i = 0; i < 10; i++) {
     StatusWithSize copy_result = entry_.Copy(new_address + (i * entry_.size()));
-    ASSERT_EQ(Status::OK, copy_result.status());
+    ASSERT_EQ(Status::Ok(), copy_result.status());
     ASSERT_EQ(kEntry1.size(), copy_result.size());
   }
 
   for (int j = 0; j < 10; j++) {
     Entry entry;
     FlashPartition::Address read_address = (new_address + (j * entry_.size()));
-    ASSERT_EQ(Status::OK,
+    ASSERT_EQ(Status::Ok(),
               Entry::Read(partition_, read_address, kFormatsWithSum, &entry));
 
-    EXPECT_EQ(Status::OK, entry.VerifyChecksumInFlash());
+    EXPECT_EQ(Status::Ok(), entry.VerifyChecksumInFlash());
     EXPECT_EQ(kFormatWithSum.magic, entry.magic());
     EXPECT_EQ(read_address, entry.address());
     EXPECT_EQ(kTransactionId1 + 6, entry.transaction_id());
@@ -561,26 +562,27 @@
 }
 
 TEST_F(ValidEntryInFlash, DifferentFormat_UpdatedCopy_FailsWithWrongMagic) {
-  ASSERT_EQ(Status::OK, entry_.Update(kFormatWithSum, kTransactionId1 + 6));
+  ASSERT_EQ(Status::Ok(), entry_.Update(kFormatWithSum, kTransactionId1 + 6));
 
   FlashPartition::Address new_address = entry_.size();
 
   StatusWithSize copy_result = entry_.Copy(new_address);
-  ASSERT_EQ(Status::OK, copy_result.status());
+  ASSERT_EQ(Status::Ok(), copy_result.status());
   ASSERT_EQ(kEntry1.size(), copy_result.size());
 
   Entry entry;
-  ASSERT_EQ(Status::DATA_LOSS,
+  ASSERT_EQ(Status::DataLoss(),
             Entry::Read(partition_, new_address, kFormats, &entry));
 }
 
 TEST_F(ValidEntryInFlash, UpdateAndCopy_WriteError) {
-  flash_.InjectWriteError(FlashError::Unconditional(Status::CANCELLED));
+  flash_.InjectWriteError(FlashError::Unconditional(Status::Cancelled()));
 
-  ASSERT_EQ(Status::OK, entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
+  ASSERT_EQ(Status::Ok(),
+            entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
 
   auto result = entry_.Copy(kEntry1.size());
-  EXPECT_EQ(Status::CANCELLED, result.status());
+  EXPECT_EQ(Status::Cancelled(), result.status());
   EXPECT_EQ(kEntry1.size(), result.size());
 }
 
diff --git a/pw_kvs/fake_flash_memory.cc b/pw_kvs/fake_flash_memory.cc
index 217870c..b649567 100644
--- a/pw_kvs/fake_flash_memory.cc
+++ b/pw_kvs/fake_flash_memory.cc
@@ -29,23 +29,23 @@
     }
   }
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status FlashError::Check(FlashMemory::Address start_address, size_t size) {
   // Check if the event overlaps with this address range.
   if (begin_ != kAnyAddress &&
       (start_address >= end_ || (start_address + size) <= begin_)) {
-    return Status::OK;
+    return Status::Ok();
   }
 
   if (delay_ > 0u) {
     delay_ -= 1;
-    return Status::OK;
+    return Status::Ok();
   }
 
   if (remaining_ == 0u) {
-    return Status::OK;
+    return Status::Ok();
   }
 
   if (remaining_ != kAlways) {
@@ -60,7 +60,7 @@
     PW_LOG_ERROR(
         "Attempted to erase sector at non-sector aligned boundary; address %x",
         unsigned(address));
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
   const size_t sector_id = address / sector_size_bytes();
   if (address / sector_size_bytes() + num_sectors > sector_count()) {
@@ -69,18 +69,18 @@
         "address: %x, sector implied: %u",
         unsigned(address),
         unsigned(sector_id));
-    return Status::OUT_OF_RANGE;
+    return Status::OutOfRange();
   }
 
   std::memset(
       &buffer_[address], int(kErasedValue), sector_size_bytes() * num_sectors);
-  return Status::OK;
+  return Status::Ok();
 }
 
 StatusWithSize FakeFlashMemory::Read(Address address,
                                      std::span<std::byte> output) {
   if (address + output.size() >= sector_count() * size_bytes()) {
-    return StatusWithSize::OUT_OF_RANGE;
+    return StatusWithSize::OutOfRange();
   }
 
   // Check for injected read errors
@@ -97,14 +97,14 @@
                  unsigned(address),
                  unsigned(data.size()),
                  unsigned(alignment_bytes()));
-    return StatusWithSize::INVALID_ARGUMENT;
+    return StatusWithSize::InvalidArgument();
   }
 
   if (data.size() > sector_size_bytes() - (address % sector_size_bytes())) {
     PW_LOG_ERROR("Write crosses sector boundary; address %x, size %u B",
                  unsigned(address),
                  unsigned(data.size()));
-    return StatusWithSize::INVALID_ARGUMENT;
+    return StatusWithSize::InvalidArgument();
   }
 
   if (address + data.size() > sector_count() * sector_size_bytes()) {
@@ -113,7 +113,7 @@
         unsigned(address),
         unsigned(data.size()),
         unsigned(sector_count() * sector_size_bytes()));
-    return StatusWithSize::OUT_OF_RANGE;
+    return StatusWithSize::OutOfRange();
   }
 
   // Check in erased state
@@ -121,7 +121,7 @@
     if (buffer_[address + i] != kErasedValue) {
       PW_LOG_ERROR("Writing to previously written address: %x",
                    unsigned(address));
-      return StatusWithSize::UNKNOWN;
+      return StatusWithSize::Unknown();
     }
   }
 
diff --git a/pw_kvs/flash_memory.cc b/pw_kvs/flash_memory.cc
index 5da2f85..ceb2d3e 100644
--- a/pw_kvs/flash_memory.cc
+++ b/pw_kvs/flash_memory.cc
@@ -43,7 +43,7 @@
 
 Status FlashPartition::Erase(Address address, size_t num_sectors) {
   if (permission_ == PartitionPermission::kReadOnly) {
-    return Status::PERMISSION_DENIED;
+    return Status::PermissionDenied();
   }
 
   PW_TRY(CheckBounds(address, num_sectors * sector_size_bytes()));
@@ -61,7 +61,7 @@
 StatusWithSize FlashPartition::Write(Address address,
                                      std::span<const byte> data) {
   if (permission_ == PartitionPermission::kReadOnly) {
-    return StatusWithSize::PERMISSION_DENIED;
+    return StatusWithSize::PermissionDenied();
   }
   PW_TRY_WITH_SIZE(CheckBounds(address, data.size()));
   const size_t address_alignment_offset = address % alignment_bytes();
@@ -76,7 +76,7 @@
                                       bool* is_erased) {
   // Relying on Read() to check address and len arguments.
   if (is_erased == nullptr) {
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
 
   // TODO(pwbug/214): Currently using a single flash alignment to do both the
@@ -86,7 +86,7 @@
   const size_t alignment = alignment_bytes();
   if (alignment > kMaxFlashAlignment || kMaxFlashAlignment % alignment ||
       length % alignment) {
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
 
   byte buffer[kMaxFlashAlignment];
@@ -101,7 +101,7 @@
     for (byte b : std::span(buffer, read_size)) {
       if (b != erased_byte) {
         // Detected memory chunk is not entirely erased
-        return Status::OK;
+        return Status::Ok();
       }
     }
 
@@ -109,7 +109,7 @@
     length -= read_size;
   }
   *is_erased = true;
-  return Status::OK;
+  return Status::Ok();
 }
 
 bool FlashPartition::AppearsErased(std::span<const byte> data) const {
@@ -128,9 +128,9 @@
         "Attempted out-of-bound flash memory access (address: %u length: %u)",
         unsigned(address),
         unsigned(length));
-    return Status::OUT_OF_RANGE;
+    return Status::OutOfRange();
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 }  // namespace pw::kvs
diff --git a/pw_kvs/flash_partition_test.cc b/pw_kvs/flash_partition_test.cc
index dd56254..aa7a12d 100644
--- a/pw_kvs/flash_partition_test.cc
+++ b/pw_kvs/flash_partition_test.cc
@@ -37,7 +37,7 @@
 
   const size_t alignment = partition.alignment_bytes();
 
-  ASSERT_EQ(Status::OK, partition.Erase(0, partition.sector_count()));
+  ASSERT_EQ(Status::Ok(), partition.Erase(0, partition.sector_count()));
 
   const size_t chunks_per_sector = partition.sector_size_bytes() / alignment;
 
@@ -53,7 +53,7 @@
          chunk_index++) {
       StatusWithSize status =
           partition.Write(address, as_bytes(std::span(test_data, alignment)));
-      ASSERT_EQ(Status::OK, status.status());
+      ASSERT_EQ(Status::Ok(), status.status());
       ASSERT_EQ(alignment, status.size());
       address += alignment;
     }
@@ -71,7 +71,7 @@
       memset(test_data, 0, sizeof(test_data));
       StatusWithSize status = partition.Read(address, alignment, test_data);
 
-      EXPECT_EQ(Status::OK, status.status());
+      EXPECT_EQ(Status::Ok(), status.status());
       EXPECT_EQ(alignment, status.size());
       if (!status.ok() || (alignment != status.size())) {
         error_count++;
@@ -140,7 +140,8 @@
       std::min(sizeof(test_data), test_partition.sector_size_bytes());
   auto data_span = std::span(test_data, block_size);
 
-  ASSERT_EQ(Status::OK, test_partition.Erase(0, test_partition.sector_count()));
+  ASSERT_EQ(Status::Ok(),
+            test_partition.Erase(0, test_partition.sector_count()));
 
   // Write to the first page of each sector.
   for (size_t sector_index = 0; sector_index < test_partition.sector_count();
@@ -149,20 +150,20 @@
         sector_index * test_partition.sector_size_bytes();
 
     StatusWithSize status = test_partition.Write(address, as_bytes(data_span));
-    ASSERT_EQ(Status::OK, status.status());
+    ASSERT_EQ(Status::Ok(), status.status());
     ASSERT_EQ(block_size, status.size());
   }
 
   // Preset the flag to make sure the check actually sets it.
   bool is_erased = true;
-  ASSERT_EQ(Status::OK, test_partition.IsErased(&is_erased));
+  ASSERT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
   ASSERT_EQ(false, is_erased);
 
-  ASSERT_EQ(Status::OK, test_partition.Erase());
+  ASSERT_EQ(Status::Ok(), test_partition.Erase());
 
   // Preset the flag to make sure the check actually sets it.
   is_erased = false;
-  ASSERT_EQ(Status::OK, test_partition.IsErased(&is_erased));
+  ASSERT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
   ASSERT_EQ(true, is_erased);
 
   // Read the first page of each sector and make sure it has been erased.
@@ -173,7 +174,7 @@
 
     StatusWithSize status =
         test_partition.Read(address, data_span.size_bytes(), data_span.data());
-    EXPECT_EQ(Status::OK, status.status());
+    EXPECT_EQ(Status::Ok(), status.status());
     EXPECT_EQ(data_span.size_bytes(), status.size());
 
     EXPECT_EQ(true, test_partition.AppearsErased(as_bytes(data_span)));
@@ -242,10 +243,10 @@
   // Make sure the partition is big enough to do this test.
   ASSERT_GE(test_partition.size_bytes(), 3 * kMaxFlashAlignment);
 
-  ASSERT_EQ(Status::OK, test_partition.Erase());
+  ASSERT_EQ(Status::Ok(), test_partition.Erase());
 
   bool is_erased = true;
-  ASSERT_EQ(Status::OK, test_partition.IsErased(&is_erased));
+  ASSERT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
   ASSERT_EQ(true, is_erased);
 
   static const uint8_t fill_byte = 0x55;
@@ -255,26 +256,26 @@
 
   // Write the chunk with fill byte.
   StatusWithSize status = test_partition.Write(alignment, as_bytes(data_span));
-  ASSERT_EQ(Status::OK, status.status());
+  ASSERT_EQ(Status::Ok(), status.status());
   ASSERT_EQ(data_span.size_bytes(), status.size());
 
-  EXPECT_EQ(Status::OK, test_partition.IsErased(&is_erased));
+  EXPECT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
   EXPECT_EQ(false, is_erased);
 
   // Check the chunk that was written.
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(Status::Ok(),
             test_partition.IsRegionErased(
                 alignment, data_span.size_bytes(), &is_erased));
   EXPECT_EQ(false, is_erased);
 
   // Check a region that starts erased but later has been written.
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(Status::Ok(),
             test_partition.IsRegionErased(0, 2 * alignment, &is_erased));
   EXPECT_EQ(false, is_erased);
 
   // Check erased for a region smaller than kMaxFlashAlignment. This has been a
   // bug in the past.
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(Status::Ok(),
             test_partition.IsRegionErased(0, alignment, &is_erased));
   EXPECT_EQ(true, is_erased);
 }
diff --git a/pw_kvs/flash_partition_with_stats.cc b/pw_kvs/flash_partition_with_stats.cc
index 25e60ad..d6fe283 100644
--- a/pw_kvs/flash_partition_with_stats.cc
+++ b/pw_kvs/flash_partition_with_stats.cc
@@ -27,7 +27,7 @@
                                                  const char* label) {
   // If size is zero saving stats is disabled so do not save any stats.
   if (sector_counters_.size() == 0) {
-    return Status::OK;
+    return Status::Ok();
   }
 
   KeyValueStore::StorageStats stats = kvs.GetStorageStats();
@@ -37,7 +37,7 @@
   std::FILE* out_file = std::fopen(file_name, "a+");
   if (out_file == nullptr) {
     PW_LOG_ERROR("Failed to dump to %s", file_name);
-    return Status::NOT_FOUND;
+    return Status::NotFound();
   }
 
   // If file is empty add the header row.
@@ -65,7 +65,7 @@
 
   std::fprintf(out_file, "\n");
   std::fclose(out_file);
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status FlashPartitionWithStats::Erase(Address address, size_t num_sectors) {
diff --git a/pw_kvs/key_value_store.cc b/pw_kvs/key_value_store.cc
index 05441d9..71da378 100644
--- a/pw_kvs/key_value_store.cc
+++ b/pw_kvs/key_value_store.cc
@@ -67,14 +67,14 @@
         "large as the number of sectors in the flash partition (=%u)",
         unsigned(sectors_.max_size()),
         unsigned(partition_.sector_count()));
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
 
   if (partition_.sector_count() < 2) {
     ERR("KVS init failed: FlashParition sector count (=%u) must be at 2. KVS "
         "requires at least 1 working sector + 1 free/reserved sector",
         unsigned(partition_.sector_count()));
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
 
   const size_t sector_size_bytes = partition_.sector_size_bytes();
@@ -85,7 +85,7 @@
         "allowed sector size (=%u)",
         unsigned(sector_size_bytes),
         unsigned(SectorDescriptor::max_sector_size()));
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
 
   Status metadata_result = InitializeMetadata();
@@ -101,7 +101,7 @@
       Status recovery_status = FixErrors();
 
       if (recovery_status.ok()) {
-        if (metadata_result == Status::OUT_OF_RANGE) {
+        if (metadata_result == Status::OutOfRange()) {
           error_stats_.missing_redundant_entries_recovered =
               pre_fix_redundancy_errors;
           INF("KVS init: Redundancy level successfully updated");
@@ -109,7 +109,7 @@
           WRN("KVS init: Corruption detected and fully repaired");
         }
         initialized_ = InitializationState::kReady;
-      } else if (recovery_status == Status::RESOURCE_EXHAUSTED) {
+      } else if (recovery_status == Status::ResourceExhausted()) {
         WRN("KVS init: Unable to maintain required free sector");
       } else {
         WRN("KVS init: Corruption detected and unable repair");
@@ -130,10 +130,10 @@
   if (error_detected_) {
     WRN("KVS init: Corruption found but not repaired, KVS unavailable until "
         "successful maintenance.");
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status KeyValueStore::InitializeMetadata() {
@@ -168,7 +168,7 @@
 
       Address next_entry_address;
       Status status = LoadEntry(entry_address, &next_entry_address);
-      if (status == Status::NOT_FOUND) {
+      if (status == Status::NotFound()) {
         DBG("Hit un-written data in sector; moving to the next sector");
         break;
       } else if (!status.ok()) {
@@ -282,7 +282,7 @@
     if (!other_errors && entry_copies_missing == entry_cache_.total_entries()) {
       INF("KVS configuration changed to redundancy of %u total copies per key",
           unsigned(redundancy()));
-      return Status::OUT_OF_RANGE;
+      return Status::OutOfRange();
     }
   }
 
@@ -292,9 +292,9 @@
         unsigned(total_corrupt_bytes),
         unsigned(corrupt_entries),
         unsigned(entry_copies_missing));
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 KeyValueStore::StorageStats KeyValueStore::GetStorageStats() const {
@@ -392,11 +392,11 @@
     if (formats_.KnownMagic(magic)) {
       DBG("Found entry magic at address %u", unsigned(address));
       *next_entry_address = address;
-      return Status::OK;
+      return Status::Ok();
     }
   }
 
-  return Status::NOT_FOUND;
+  return Status::NotFound();
 }
 
 StatusWithSize KeyValueStore::Get(string_view key,
@@ -420,7 +420,7 @@
     DBG("%u B value with %u B key cannot fit in one sector",
         unsigned(value.size()),
         unsigned(key.size()));
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
 
   EntryMetadata metadata;
@@ -435,7 +435,7 @@
     return WriteEntryForExistingKey(metadata, EntryState::kValid, key, value);
   }
 
-  if (status == Status::NOT_FOUND) {
+  if (status == Status::NotFound()) {
     return WriteEntryForNewKey(key, value);
   }
 
@@ -495,7 +495,7 @@
 Status KeyValueStore::ReadEntry(const EntryMetadata& metadata,
                                 Entry& entry) const {
   // Try to read an entry
-  Status read_result = Status::DATA_LOSS;
+  Status read_result = Status::DataLoss();
   for (Address address : metadata.addresses()) {
     read_result = Entry::Read(partition_, address, formats_, &entry);
     if (read_result.ok()) {
@@ -528,9 +528,9 @@
 
   // If the key's hash collides with an existing key or if the key is deleted,
   // treat it as if it is not in the KVS.
-  if (status == Status::ALREADY_EXISTS ||
+  if (status == Status::AlreadyExists() ||
       (status.ok() && metadata->state() == EntryState::kDeleted)) {
-    return Status::NOT_FOUND;
+    return Status::NotFound();
   }
   return status;
 }
@@ -580,7 +580,7 @@
     DBG("Requested %u B read, but value is %u B",
         unsigned(size_bytes),
         unsigned(actual_size));
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
 
   StatusWithSize result =
@@ -598,27 +598,27 @@
 
 Status KeyValueStore::CheckWriteOperation(string_view key) const {
   if (InvalidKey(key)) {
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
 
   // For normal write operation the KVS must be fully ready.
   if (!initialized()) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status KeyValueStore::CheckReadOperation(string_view key) const {
   if (InvalidKey(key)) {
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
 
   // Operations that are explicitly read-only can be done after init() has been
   // called but not fully ready (when needing maintenance).
   if (initialized_ == InitializationState::kNotInitialized) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status KeyValueStore::WriteEntryForExistingKey(EntryMetadata& metadata,
@@ -637,7 +637,7 @@
   if (entry_cache_.full()) {
     WRN("KVS full: trying to store a new entry, but can't. Have %u entries",
         unsigned(entry_cache_.total_entries()));
-    return Status::RESOURCE_EXHAUSTED;
+    return Status::ResourceExhausted();
   }
 
   return WriteEntry(key, value, EntryState::kValid);
@@ -659,7 +659,7 @@
     // keep the existing entry.
     DBG("Write for key 0x%08x with matching value skipped",
         unsigned(prior_metadata->hash()));
-    return Status::OK;
+    return Status::Ok();
   }
 
   // List of addresses for sectors with space for this entry.
@@ -686,7 +686,7 @@
     PW_TRY(AppendEntry(entry, key, value));
     new_metadata.AddNewAddress(reserved_addresses[i]);
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 KeyValueStore::EntryMetadata KeyValueStore::CreateOrUpdateKeyDescriptor(
@@ -730,7 +730,7 @@
         unsigned(write_addresses[i]));
   }
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 // Finds a sector to use for writing a new entry to. Does automatic garbage
@@ -747,7 +747,7 @@
   bool do_auto_gc = options_.gc_on_write != GargbageCollectOnWrite::kDisabled;
 
   // Do garbage collection as needed, so long as policy allows.
-  while (result == Status::RESOURCE_EXHAUSTED && do_auto_gc) {
+  while (result == Status::ResourceExhausted() && do_auto_gc) {
     if (options_.gc_on_write == GargbageCollectOnWrite::kOneSector) {
       // If GC config option is kOneSector clear the flag to not do any more
       // GC after this try.
@@ -756,9 +756,9 @@
     // Garbage collect and then try again to find the best sector.
     Status gc_status = GarbageCollect(reserved);
     if (!gc_status.ok()) {
-      if (gc_status == Status::NOT_FOUND) {
+      if (gc_status == Status::NotFound()) {
         // Not enough space, and no reclaimable bytes, this KVS is full!
-        return Status::RESOURCE_EXHAUSTED;
+        return Status::ResourceExhausted();
       }
       return gc_status;
     }
@@ -772,7 +772,7 @@
     // that have copies of the key trying to be written.
     if (gc_sector_count > (partition_.sector_count() + 2)) {
       ERR("Did more GC sectors than total sectors!!!!");
-      return Status::RESOURCE_EXHAUSTED;
+      return Status::ResourceExhausted();
     }
   }
 
@@ -813,7 +813,7 @@
 
   sector.RemoveWritableBytes(result.size());
   sector.AddValidBytes(result.size());
-  return Status::OK;
+  return Status::Ok();
 }
 
 StatusWithSize KeyValueStore::CopyEntryToSector(Entry& entry,
@@ -864,12 +864,12 @@
   sectors_.FromAddress(address).RemoveValidBytes(result_size);
   address = new_address;
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status KeyValueStore::FullMaintenance() {
   if (initialized_ == InitializationState::kNotInitialized) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
 
   // Full maintenance can be a potentially heavy operation, and should be
@@ -931,7 +931,7 @@
 
 Status KeyValueStore::PartialMaintenance() {
   if (initialized_ == InitializationState::kNotInitialized) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
 
   CheckForErrors();
@@ -955,7 +955,7 @@
 
   if (sector_to_gc == nullptr) {
     // Nothing to GC.
-    return Status::NOT_FOUND;
+    return Status::NotFound();
   }
 
   // Step 2: Garbage collect the selected sector.
@@ -975,7 +975,7 @@
     }
   }
 
-  return Status::OK;
+  return Status::Ok();
 };
 
 Status KeyValueStore::GarbageCollectSector(
@@ -994,7 +994,7 @@
     ERR("  Failed to relocate valid entries from sector being garbage "
         "collected, %u valid bytes remain",
         unsigned(sector_to_gc.valid_bytes()));
-    return Status::INTERNAL;
+    return Status::Internal();
   }
 
   // Step 2: Reinitialize the sector
@@ -1003,7 +1003,7 @@
   sector_to_gc.set_writable_bytes(partition_.sector_size_bytes());
 
   DBG("  Garbage Collect sector %u complete", sectors_.Index(sector_to_gc));
-  return Status::OK;
+  return Status::Ok();
 }
 
 StatusWithSize KeyValueStore::UpdateEntriesToPrimaryFormat() {
@@ -1073,7 +1073,7 @@
 
     metadata.AddNewAddress(new_address);
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status KeyValueStore::RepairCorruptSectors() {
@@ -1081,15 +1081,15 @@
   // sector failed on the first pass, then do a second pass, since a later
   // sector might have cleared up space or otherwise unblocked the earlier
   // failed sector.
-  Status repair_status = Status::OK;
+  Status repair_status = Status::Ok();
 
   size_t loop_count = 0;
   do {
     loop_count++;
     // Error of RESOURCE_EXHAUSTED indicates no space found for relocation.
     // Reset back to OK for the next pass.
-    if (repair_status == Status::RESOURCE_EXHAUSTED) {
-      repair_status = Status::OK;
+    if (repair_status == Status::ResourceExhausted()) {
+      repair_status = Status::Ok();
     }
 
     DBG("   Pass %u", unsigned(loop_count));
@@ -1100,7 +1100,7 @@
         if (sector_status.ok()) {
           error_stats_.corrupt_sectors_recovered += 1;
         } else if (repair_status.ok() ||
-                   repair_status == Status::RESOURCE_EXHAUSTED) {
+                   repair_status == Status::ResourceExhausted()) {
           repair_status = sector_status;
         }
       }
@@ -1112,7 +1112,7 @@
 }
 
 Status KeyValueStore::EnsureFreeSectorExists() {
-  Status repair_status = Status::OK;
+  Status repair_status = Status::Ok();
   bool empty_sector_found = false;
 
   DBG("   Find empty sector");
@@ -1136,11 +1136,11 @@
 }
 
 Status KeyValueStore::EnsureEntryRedundancy() {
-  Status repair_status = Status::OK;
+  Status repair_status = Status::Ok();
 
   if (redundancy() == 1) {
     DBG("   Redundancy not in use, nothting to check");
-    return Status::OK;
+    return Status::Ok();
   }
 
   DBG("   Write any needed additional duplicate copies of keys to fulfill %u"
diff --git a/pw_kvs/key_value_store_binary_format_test.cc b/pw_kvs/key_value_store_binary_format_test.cc
index ba2964a..ea1b596 100644
--- a/pw_kvs/key_value_store_binary_format_test.cc
+++ b/pw_kvs/key_value_store_binary_format_test.cc
@@ -189,19 +189,19 @@
 TEST_F(KvsErrorHandling, Init_Ok) {
   InitFlashTo(bytes::Concat(kEntry1, kEntry2));
 
-  EXPECT_EQ(Status::OK, kvs_.Init());
+  EXPECT_EQ(Status::Ok(), kvs_.Init());
   byte buffer[64];
-  EXPECT_EQ(Status::OK, kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+  EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
 }
 
 TEST_F(KvsErrorHandling, Init_DuplicateEntries_ReturnsDataLossButReadsEntry) {
   InitFlashTo(bytes::Concat(kEntry1, kEntry1));
 
-  EXPECT_EQ(Status::DATA_LOSS, kvs_.Init());
+  EXPECT_EQ(Status::DataLoss(), kvs_.Init());
   byte buffer[64];
-  EXPECT_EQ(Status::OK, kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+  EXPECT_EQ(Status::NotFound(), kvs_.Get("k2", buffer).status());
 }
 
 TEST_F(KvsErrorHandling, Init_CorruptEntry_FindsSubsequentValidEntry) {
@@ -210,10 +210,10 @@
     InitFlashTo(bytes::Concat(kEntry1, kEntry2));
     flash_.buffer()[i] = byte(int(flash_.buffer()[i]) + 1);
 
-    ASSERT_EQ(Status::DATA_LOSS, kvs_.Init());
+    ASSERT_EQ(Status::DataLoss(), kvs_.Init());
     byte buffer[64];
-    ASSERT_EQ(Status::NOT_FOUND, kvs_.Get("key1", buffer).status());
-    ASSERT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
+    ASSERT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
+    ASSERT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
 
     auto stats = kvs_.GetStorageStats();
     // One valid entry.
@@ -230,15 +230,15 @@
   flash_.buffer()[9] = byte(0xef);
   flash_.buffer()[67] = byte(0xef);
 
-  ASSERT_EQ(Status::DATA_LOSS, kvs_.Init());
+  ASSERT_EQ(Status::DataLoss(), kvs_.Init());
 
   EXPECT_EQ(2u, kvs_.size());
 
   byte buffer[64];
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("k3y", buffer).status());
-  EXPECT_EQ(Status::OK, kvs_.Get("4k", buffer).status());
+  EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
+  EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(Status::NotFound(), kvs_.Get("k3y", buffer).status());
+  EXPECT_EQ(Status::Ok(), kvs_.Get("4k", buffer).status());
 
   auto stats = kvs_.GetStorageStats();
   ASSERT_EQ(64u, stats.in_use_bytes);
@@ -250,9 +250,9 @@
   InitFlashTo(bytes::Concat(kEntry1, kEntry2));
 
   flash_.InjectReadError(
-      FlashError::InRange(Status::UNAUTHENTICATED, kEntry1.size()));
+      FlashError::InRange(Status::Unauthenticated(), kEntry1.size()));
 
-  EXPECT_EQ(Status::DATA_LOSS, kvs_.Init());
+  EXPECT_EQ(Status::DataLoss(), kvs_.Init());
   EXPECT_FALSE(kvs_.initialized());
 }
 
@@ -267,16 +267,16 @@
   flash_.buffer()[513] = byte(0xef);
   flash_.buffer()[1025] = byte(0xef);
 
-  ASSERT_EQ(Status::DATA_LOSS, kvs_.Init());
-  EXPECT_EQ(Status::FAILED_PRECONDITION,
+  ASSERT_EQ(Status::DataLoss(), kvs_.Init());
+  EXPECT_EQ(Status::FailedPrecondition(),
             kvs_.Put("hello", bytes::String("world")));
-  EXPECT_EQ(Status::FAILED_PRECONDITION, kvs_.Put("a", bytes::String("b")));
+  EXPECT_EQ(Status::FailedPrecondition(), kvs_.Put("a", bytes::String("b")));
 
   // Existing valid entries should still be readable.
   EXPECT_EQ(1u, kvs_.size());
   byte buffer[64];
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
+  EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
 
   auto stats = kvs_.GetStorageStats();
   EXPECT_EQ(32u, stats.in_use_bytes);
@@ -295,7 +295,7 @@
   flash_.buffer()[1025] = byte(0xef);
   flash_.buffer()[1537] = byte(0xef);
 
-  ASSERT_EQ(Status::DATA_LOSS, kvs_.Init());
+  ASSERT_EQ(Status::DataLoss(), kvs_.Init());
 
   auto stats = kvs_.GetStorageStats();
   EXPECT_EQ(64u, stats.in_use_bytes);
@@ -310,12 +310,12 @@
 TEST_F(KvsErrorHandling, DISABLED_Init_OkWithWriteErrorOnFlash) {
   InitFlashTo(bytes::Concat(kEntry1, kEmpty32Bytes, kEntry2));
 
-  EXPECT_EQ(Status::DATA_LOSS, kvs_.Init());
+  EXPECT_EQ(Status::DataLoss(), kvs_.Init());
   byte buffer[64];
   EXPECT_EQ(2u, kvs_.size());
   EXPECT_EQ(true, kvs_.error_detected());
-  EXPECT_EQ(Status::OK, kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+  EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
 
   auto stats = kvs_.GetStorageStats();
   EXPECT_EQ(64u, stats.in_use_bytes);
@@ -334,14 +334,14 @@
   // Corrupt a byte of entry version 8 (addresses 32-63).
   flash_.buffer()[34] = byte(0xef);
 
-  ASSERT_EQ(Status::DATA_LOSS, kvs_.Init());
+  ASSERT_EQ(Status::DataLoss(), kvs_.Init());
 
   char buffer[64] = {};
 
   EXPECT_EQ(1u, kvs_.size());
 
   auto result = kvs_.Get("my_key", std::as_writable_bytes(std::span(buffer)));
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(sizeof("version 7") - 1, result.size());
   EXPECT_STREQ("version 7", buffer);
 
@@ -352,12 +352,12 @@
 // the KvsErrorRecovery and KvsErrorHandling test fixtures (different KVS
 // configurations).
 TEST_F(KvsErrorHandling, Put_WriteFailure_EntryNotAddedButBytesMarkedWritten) {
-  ASSERT_EQ(Status::OK, kvs_.Init());
-  flash_.InjectWriteError(FlashError::Unconditional(Status::UNAVAILABLE, 1));
+  ASSERT_EQ(Status::Ok(), kvs_.Init());
+  flash_.InjectWriteError(FlashError::Unconditional(Status::Unavailable(), 1));
 
-  EXPECT_EQ(Status::UNAVAILABLE, kvs_.Put("key1", bytes::String("value1")));
+  EXPECT_EQ(Status::Unavailable(), kvs_.Put("key1", bytes::String("value1")));
 
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("key1", std::span<byte>()).status());
+  EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", std::span<byte>()).status());
   ASSERT_TRUE(kvs_.empty());
 
   auto stats = kvs_.GetStorageStats();
@@ -367,7 +367,7 @@
 
   // The bytes were marked used, so a new key should not overlap with the bytes
   // from the failed Put.
-  EXPECT_EQ(Status::OK, kvs_.Put("key1", bytes::String("value1")));
+  EXPECT_EQ(Status::Ok(), kvs_.Put("key1", bytes::String("value1")));
 
   stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.in_use_bytes, (32u * kvs_.redundancy()));
@@ -397,22 +397,22 @@
 TEST_F(KvsErrorRecovery, Init_Ok) {
   InitFlashTo(bytes::Concat(kEntry1, kEntry2));
 
-  EXPECT_EQ(Status::OK, kvs_.Init());
+  EXPECT_EQ(Status::Ok(), kvs_.Init());
   byte buffer[64];
-  EXPECT_EQ(Status::OK, kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+  EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
 }
 
 TEST_F(KvsErrorRecovery, Init_DuplicateEntries_RecoversDuringInit) {
   InitFlashTo(bytes::Concat(kEntry1, kEntry1));
 
-  EXPECT_EQ(Status::OK, kvs_.Init());
+  EXPECT_EQ(Status::Ok(), kvs_.Init());
   auto stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.corrupt_sectors_recovered, 1u);
 
   byte buffer[64];
-  EXPECT_EQ(Status::OK, kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+  EXPECT_EQ(Status::NotFound(), kvs_.Get("k2", buffer).status());
 }
 
 TEST_F(KvsErrorRecovery, Init_CorruptEntry_FindsSubsequentValidEntry) {
@@ -421,10 +421,10 @@
     InitFlashTo(bytes::Concat(kEntry1, kEntry2));
     flash_.buffer()[i] = byte(int(flash_.buffer()[i]) + 1);
 
-    ASSERT_EQ(Status::OK, kvs_.Init());
+    ASSERT_EQ(Status::Ok(), kvs_.Init());
     byte buffer[64];
-    ASSERT_EQ(Status::NOT_FOUND, kvs_.Get("key1", buffer).status());
-    ASSERT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
+    ASSERT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
+    ASSERT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
 
     auto stats = kvs_.GetStorageStats();
     // One valid entry.
@@ -442,15 +442,15 @@
   flash_.buffer()[9] = byte(0xef);
   flash_.buffer()[67] = byte(0xef);
 
-  ASSERT_EQ(Status::OK, kvs_.Init());
+  ASSERT_EQ(Status::Ok(), kvs_.Init());
 
   EXPECT_EQ(2u, kvs_.size());
 
   byte buffer[64];
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("k3y", buffer).status());
-  EXPECT_EQ(Status::OK, kvs_.Get("4k", buffer).status());
+  EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
+  EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(Status::NotFound(), kvs_.Get("k3y", buffer).status());
+  EXPECT_EQ(Status::Ok(), kvs_.Get("4k", buffer).status());
 
   auto stats = kvs_.GetStorageStats();
   ASSERT_EQ(64u, stats.in_use_bytes);
@@ -463,9 +463,9 @@
   InitFlashTo(bytes::Concat(kEntry1, kEntry2));
 
   flash_.InjectReadError(
-      FlashError::InRange(Status::UNAUTHENTICATED, kEntry1.size()));
+      FlashError::InRange(Status::Unauthenticated(), kEntry1.size()));
 
-  EXPECT_EQ(Status::OK, kvs_.Init());
+  EXPECT_EQ(Status::Ok(), kvs_.Init());
   EXPECT_TRUE(kvs_.initialized());
   auto stats = kvs_.GetStorageStats();
   ASSERT_EQ(32u, stats.in_use_bytes);
@@ -484,15 +484,15 @@
   flash_.buffer()[513] = byte(0xef);
   flash_.buffer()[1025] = byte(0xef);
 
-  ASSERT_EQ(Status::OK, kvs_.Init());
-  EXPECT_EQ(Status::OK, kvs_.Put("hello", bytes::String("world")));
-  EXPECT_EQ(Status::OK, kvs_.Put("a", bytes::String("b")));
+  ASSERT_EQ(Status::Ok(), kvs_.Init());
+  EXPECT_EQ(Status::Ok(), kvs_.Put("hello", bytes::String("world")));
+  EXPECT_EQ(Status::Ok(), kvs_.Put("a", bytes::String("b")));
 
   // Existing valid entries should still be readable.
   EXPECT_EQ(3u, kvs_.size());
   byte buffer[64];
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
+  EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
 
   auto stats = kvs_.GetStorageStats();
   EXPECT_EQ(96u, stats.in_use_bytes);
@@ -512,7 +512,7 @@
   flash_.buffer()[1025] = byte(0xef);
   flash_.buffer()[1537] = byte(0xef);
 
-  ASSERT_EQ(Status::OK, kvs_.Init());
+  ASSERT_EQ(Status::Ok(), kvs_.Init());
 
   auto stats = kvs_.GetStorageStats();
   EXPECT_EQ(64u, stats.in_use_bytes);
@@ -528,12 +528,12 @@
 TEST_F(KvsErrorRecovery, DISABLED_Init_OkWithWriteErrorOnFlash) {
   InitFlashTo(bytes::Concat(kEntry1, kEmpty32Bytes, kEntry2));
 
-  EXPECT_EQ(Status::OK, kvs_.Init());
+  EXPECT_EQ(Status::Ok(), kvs_.Init());
   byte buffer[64];
   EXPECT_EQ(2u, kvs_.size());
   EXPECT_EQ(false, kvs_.error_detected());
-  EXPECT_EQ(Status::OK, kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+  EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
 
   auto stats = kvs_.GetStorageStats();
   EXPECT_EQ(64u, stats.in_use_bytes);
@@ -554,14 +554,14 @@
   // Corrupt a byte of entry version 8 (addresses 32-63).
   flash_.buffer()[34] = byte(0xef);
 
-  ASSERT_EQ(Status::OK, kvs_.Init());
+  ASSERT_EQ(Status::Ok(), kvs_.Init());
 
   char buffer[64] = {};
 
   EXPECT_EQ(1u, kvs_.size());
 
   auto result = kvs_.Get("my_key", std::as_writable_bytes(std::span(buffer)));
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(sizeof("version 7") - 1, result.size());
   EXPECT_STREQ("version 7", buffer);
 
@@ -572,13 +572,13 @@
 // the KvsErrorRecovery and KvsErrorHandling test fixtures (different KVS
 // configurations).
 TEST_F(KvsErrorRecovery, Put_WriteFailure_EntryNotAddedButBytesMarkedWritten) {
-  ASSERT_EQ(Status::OK, kvs_.Init());
-  flash_.InjectWriteError(FlashError::Unconditional(Status::UNAVAILABLE, 1));
+  ASSERT_EQ(Status::Ok(), kvs_.Init());
+  flash_.InjectWriteError(FlashError::Unconditional(Status::Unavailable(), 1));
 
-  EXPECT_EQ(Status::UNAVAILABLE, kvs_.Put("key1", bytes::String("value1")));
+  EXPECT_EQ(Status::Unavailable(), kvs_.Put("key1", bytes::String("value1")));
   EXPECT_EQ(true, kvs_.error_detected());
 
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("key1", std::span<byte>()).status());
+  EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", std::span<byte>()).status());
   ASSERT_TRUE(kvs_.empty());
 
   auto stats = kvs_.GetStorageStats();
@@ -590,7 +590,7 @@
 
   // The bytes were marked used, so a new key should not overlap with the bytes
   // from the failed Put.
-  EXPECT_EQ(Status::OK, kvs_.Put("key1", bytes::String("value1")));
+  EXPECT_EQ(Status::Ok(), kvs_.Put("key1", bytes::String("value1")));
 
   stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.in_use_bytes, (32u * kvs_.redundancy()));
@@ -647,7 +647,7 @@
                 kInitialContents.data(),
                 kInitialContents.size());
 
-    EXPECT_EQ(Status::OK, kvs_.Init());
+    EXPECT_EQ(Status::Ok(), kvs_.Init());
   }
 
   FakeFlashMemoryBuffer<512, 4, 3> flash_;
@@ -660,7 +660,7 @@
     char val[sizeof(str_value)] = {};                          \
     StatusWithSize stat =                                      \
         kvs_.Get(key, std::as_writable_bytes(std::span(val))); \
-    ASSERT_EQ(Status::OK, stat.status());                      \
+    ASSERT_EQ(Status::Ok(), stat.status());                    \
     ASSERT_EQ(sizeof(str_value) - 1, stat.size());             \
     ASSERT_STREQ(str_value, val);                              \
   } while (0)
@@ -681,7 +681,7 @@
   EXPECT_EQ(stats.corrupt_sectors_recovered, 0u);
   EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
 
-  EXPECT_EQ(Status::OK, partition_.Erase(0, 1));
+  EXPECT_EQ(Status::Ok(), partition_.Erase(0, 1));
 
   ASSERT_CONTAINS_ENTRY("key1", "value1");
   ASSERT_CONTAINS_ENTRY("k2", "value2");
@@ -698,7 +698,7 @@
   EXPECT_EQ(stats.corrupt_sectors_recovered, 0u);
   EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
 
-  EXPECT_EQ(Status::OK, kvs_.FullMaintenance());
+  EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
   stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.in_use_bytes, (192u * kvs_.redundancy()));
   EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -715,7 +715,7 @@
   EXPECT_EQ(stats.corrupt_sectors_recovered, 0u);
   EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
 
-  EXPECT_EQ(Status::OK, partition_.Erase(partition_.sector_size_bytes(), 1));
+  EXPECT_EQ(Status::Ok(), partition_.Erase(partition_.sector_size_bytes(), 1));
 
   ASSERT_CONTAINS_ENTRY("key1", "value1");
   ASSERT_CONTAINS_ENTRY("k2", "value2");
@@ -736,9 +736,9 @@
 
 TEST_F(InitializedRedundantMultiMagicKvs, SingleReadErrors) {
   // Inject 2 read errors, so the first read attempt fully fails.
-  flash_.InjectReadError(FlashError::Unconditional(Status::INTERNAL, 2));
+  flash_.InjectReadError(FlashError::Unconditional(Status::Internal(), 2));
 
-  flash_.InjectReadError(FlashError::Unconditional(Status::INTERNAL, 1, 7));
+  flash_.InjectReadError(FlashError::Unconditional(Status::Internal(), 1, 7));
 
   ASSERT_CONTAINS_ENTRY("key1", "value1");
   ASSERT_CONTAINS_ENTRY("k2", "value2");
@@ -757,9 +757,9 @@
 }
 
 TEST_F(InitializedRedundantMultiMagicKvs, SingleWriteError) {
-  flash_.InjectWriteError(FlashError::Unconditional(Status::INTERNAL, 1, 1));
+  flash_.InjectWriteError(FlashError::Unconditional(Status::Internal(), 1, 1));
 
-  EXPECT_EQ(Status::INTERNAL, kvs_.Put("new key", bytes::String("abcd?")));
+  EXPECT_EQ(Status::Internal(), kvs_.Put("new key", bytes::String("abcd?")));
 
   EXPECT_EQ(true, kvs_.error_detected());
 
@@ -773,10 +773,10 @@
 
   char val[20] = {};
   EXPECT_EQ(
-      Status::OK,
+      Status::Ok(),
       kvs_.Get("new key", std::as_writable_bytes(std::span(val))).status());
 
-  EXPECT_EQ(Status::OK, kvs_.FullMaintenance());
+  EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
   stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.in_use_bytes, (224u * kvs_.redundancy()));
   EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -785,23 +785,23 @@
   EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
 
   EXPECT_EQ(
-      Status::OK,
+      Status::Ok(),
       kvs_.Get("new key", std::as_writable_bytes(std::span(val))).status());
 }
 
 TEST_F(InitializedRedundantMultiMagicKvs, DataLossAfterLosingBothCopies) {
-  EXPECT_EQ(Status::OK, partition_.Erase(0, 2));
+  EXPECT_EQ(Status::Ok(), partition_.Erase(0, 2));
 
   char val[20] = {};
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             kvs_.Get("key1", std::as_writable_bytes(std::span(val))).status());
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             kvs_.Get("k2", std::as_writable_bytes(std::span(val))).status());
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             kvs_.Get("k3y", std::as_writable_bytes(std::span(val))).status());
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             kvs_.Get("A Key", std::as_writable_bytes(std::span(val))).status());
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             kvs_.Get("kee", std::as_writable_bytes(std::span(val))).status());
 
   EXPECT_EQ(true, kvs_.error_detected());
@@ -815,7 +815,7 @@
 }
 
 TEST_F(InitializedRedundantMultiMagicKvs, PutNewEntry_UsesFirstFormat) {
-  EXPECT_EQ(Status::OK, kvs_.Put("new key", bytes::String("abcd?")));
+  EXPECT_EQ(Status::Ok(), kvs_.Put("new key", bytes::String("abcd?")));
 
   constexpr auto kNewEntry =
       MakeValidEntry(kMagic, 129, "new key", bytes::String("abcd?"));
@@ -827,7 +827,7 @@
 }
 
 TEST_F(InitializedRedundantMultiMagicKvs, PutExistingEntry_UsesFirstFormat) {
-  EXPECT_EQ(Status::OK, kvs_.Put("A Key", bytes::String("New value!")));
+  EXPECT_EQ(Status::Ok(), kvs_.Put("A Key", bytes::String("New value!")));
 
   constexpr auto kNewEntry =
       MakeValidEntry(kMagic, 129, "A Key", bytes::String("New value!"));
@@ -843,20 +843,20 @@
     char val[sizeof(str_value)] = {};                         \
     StatusWithSize stat =                                     \
         kvs.Get(key, std::as_writable_bytes(std::span(val))); \
-    ASSERT_EQ(Status::OK, stat.status());                     \
+    ASSERT_EQ(Status::Ok(), stat.status());                   \
     ASSERT_EQ(sizeof(str_value) - 1, stat.size());            \
     ASSERT_STREQ(str_value, val);                             \
   } while (0)
 
 TEST_F(InitializedRedundantMultiMagicKvs, UpdateEntryFormat) {
-  ASSERT_EQ(Status::OK, kvs_.FullMaintenance());
+  ASSERT_EQ(Status::Ok(), kvs_.FullMaintenance());
 
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors, 2, 1> local_kvs(
       &partition_,
       {.magic = kMagic, .checksum = &default_checksum},
       kNoGcOptions);
 
-  ASSERT_EQ(Status::OK, local_kvs.Init());
+  ASSERT_EQ(Status::Ok(), local_kvs.Init());
   EXPECT_EQ(false, local_kvs.error_detected());
   ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "key1", "value1");
   ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "k2", "value2");
@@ -885,7 +885,7 @@
                 kInitialContents.data(),
                 kInitialContents.size());
 
-    EXPECT_EQ(Status::OK, kvs_.Init());
+    EXPECT_EQ(Status::Ok(), kvs_.Init());
   }
 
   FakeFlashMemoryBuffer<512, 4, 3> flash_;
@@ -906,14 +906,14 @@
 // Similar to test for InitializedRedundantMultiMagicKvs. Doing similar test
 // with different KVS configuration.
 TEST_F(InitializedMultiMagicKvs, UpdateEntryFormat) {
-  ASSERT_EQ(Status::OK, kvs_.FullMaintenance());
+  ASSERT_EQ(Status::Ok(), kvs_.FullMaintenance());
 
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors, 1, 1> local_kvs(
       &partition_,
       {.magic = kMagic, .checksum = &default_checksum},
       kNoGcOptions);
 
-  ASSERT_EQ(Status::OK, local_kvs.Init());
+  ASSERT_EQ(Status::Ok(), local_kvs.Init());
   EXPECT_EQ(false, local_kvs.error_detected());
   ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "key1", "value1");
   ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "k2", "value2");
@@ -938,7 +938,7 @@
                 kInitialContents.data(),
                 kInitialContents.size());
 
-    EXPECT_EQ(Status::OK, kvs_.Init());
+    EXPECT_EQ(Status::Ok(), kvs_.Init());
   }
 
   FakeFlashMemoryBuffer<512, 4, 3> flash_;
@@ -947,16 +947,16 @@
 };
 
 TEST_F(InitializedRedundantLazyRecoveryKvs, WriteAfterDataLoss) {
-  EXPECT_EQ(Status::OK, partition_.Erase(0, 4));
+  EXPECT_EQ(Status::Ok(), partition_.Erase(0, 4));
 
   char val[20] = {};
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             kvs_.Get("key1", std::as_writable_bytes(std::span(val))).status());
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             kvs_.Get("k2", std::as_writable_bytes(std::span(val))).status());
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             kvs_.Get("k3y", std::as_writable_bytes(std::span(val))).status());
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             kvs_.Get("4k", std::as_writable_bytes(std::span(val))).status());
 
   EXPECT_EQ(true, kvs_.error_detected());
@@ -968,9 +968,9 @@
   EXPECT_EQ(stats.corrupt_sectors_recovered, 0u);
   EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
 
-  ASSERT_EQ(Status::DATA_LOSS, kvs_.Put("key1", 1000));
+  ASSERT_EQ(Status::DataLoss(), kvs_.Put("key1", 1000));
 
-  EXPECT_EQ(Status::OK, kvs_.FullMaintenance());
+  EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
   stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.in_use_bytes, 0u);
   EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -1005,7 +1005,7 @@
   ASSERT_CONTAINS_ENTRY("k3y", "value3");
   ASSERT_CONTAINS_ENTRY("4k", "value4");
 
-  EXPECT_EQ(Status::OK, kvs_.FullMaintenance());
+  EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
   stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.in_use_bytes, (128u * kvs_.redundancy()));
   EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -1030,7 +1030,7 @@
                 kInitialContents.data(),
                 kInitialContents.size());
 
-    EXPECT_EQ(Status::OK, kvs_.Init());
+    EXPECT_EQ(Status::Ok(), kvs_.Init());
   }
 
   FakeFlashMemoryBuffer<512, 8> flash_;
@@ -1066,17 +1066,17 @@
   // Add a near-sector size key entry to fill the KVS with a valid large entry
   // and stale data. Modify the value in between Puts so it actually writes
   // (identical value writes are skipped).
-  EXPECT_EQ(Status::OK, kvs_.Put("big_key", test_data));
+  EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
   test_data[0]++;
-  EXPECT_EQ(Status::OK, kvs_.Put("big_key", test_data));
+  EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
   test_data[0]++;
-  EXPECT_EQ(Status::OK, kvs_.Put("big_key", test_data));
+  EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
   test_data[0]++;
-  EXPECT_EQ(Status::OK, kvs_.Put("big_key", test_data));
+  EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
   test_data[0]++;
-  EXPECT_EQ(Status::OK, kvs_.Put("big_key", test_data));
+  EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
   test_data[0]++;
-  EXPECT_EQ(Status::OK, kvs_.Put("big_key", test_data));
+  EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
 
   // Instantiate a new KVS with redundancy of 2. This KVS should add an extra
   // copy of each valid key as part of the init process. Because there is not
@@ -1086,7 +1086,7 @@
       &partition_,
       {.magic = kMagic, .checksum = &default_checksum},
       kRecoveryLazyGcOptions);
-  ASSERT_EQ(Status::OK, local_kvs.Init());
+  ASSERT_EQ(Status::Ok(), local_kvs.Init());
 
   // Verify no errors found in the new KVS and all the entries are present.
   EXPECT_EQ(false, local_kvs.error_detected());
@@ -1095,7 +1095,7 @@
   ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "k3y", "value3");
   ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "4k", "value4");
   StatusWithSize big_key_size = local_kvs.ValueSize("big_key");
-  EXPECT_EQ(Status::OK, big_key_size.status());
+  EXPECT_EQ(Status::Ok(), big_key_size.status());
   EXPECT_EQ(sizeof(test_data), big_key_size.size());
 
   // Verify that storage stats of the new redundant KVS match expected values.
diff --git a/pw_kvs/key_value_store_fuzz_test.cc b/pw_kvs/key_value_store_fuzz_test.cc
index fcfca4c..4fd86bc 100644
--- a/pw_kvs/key_value_store_fuzz_test.cc
+++ b/pw_kvs/key_value_store_fuzz_test.cc
@@ -46,7 +46,7 @@
   EmptyInitializedKvs()
       : kvs_(&test_partition, {.magic = 0x873a9b50, .checksum = &checksum}) {
     test_partition.Erase(0, test_partition.sector_count());
-    ASSERT_EQ(Status::OK, kvs_.Init());
+    ASSERT_EQ(Status::Ok(), kvs_.Init());
   }
 
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs_;
@@ -63,7 +63,7 @@
   for (int i = 0; i < kFuzzIterations; ++i) {
     for (unsigned key_size = 1; key_size < sizeof(value); ++key_size) {
       for (unsigned value_size = 0; value_size < sizeof(value); ++value_size) {
-        ASSERT_EQ(Status::OK,
+        ASSERT_EQ(Status::Ok(),
                   kvs_.Put(std::string_view(value, key_size),
                            std::as_bytes(std::span(value, value_size))));
       }
diff --git a/pw_kvs/key_value_store_initialized_test.cc b/pw_kvs/key_value_store_initialized_test.cc
index 6ed0b52..7ea3fd9 100644
--- a/pw_kvs/key_value_store_initialized_test.cc
+++ b/pw_kvs/key_value_store_initialized_test.cc
@@ -83,7 +83,7 @@
  protected:
   EmptyInitializedKvs() : kvs_(&test_partition, default_format) {
     test_partition.Erase();
-    ASSERT_EQ(Status::OK, kvs_.Init());
+    ASSERT_EQ(Status::Ok(), kvs_.Init());
   }
 
   // Intention of this is to put and erase key-val to fill up sectors. It's a
@@ -107,7 +107,7 @@
     while (size_to_fill > 0) {
       // Changing buffer value so put actually does something
       buffer[0] = static_cast<byte>(static_cast<uint8_t>(buffer[0]) + 1);
-      ASSERT_EQ(Status::OK,
+      ASSERT_EQ(Status::Ok(),
                 kvs_.Put(key,
                          std::span(buffer.data(),
                                    chunk_len - kvs_attr.ChunkHeaderSize() -
@@ -115,7 +115,7 @@
       size_to_fill -= chunk_len;
       chunk_len = std::min(size_to_fill, kMaxPutSize);
     }
-    ASSERT_EQ(Status::OK, kvs_.Delete(key));
+    ASSERT_EQ(Status::Ok(), kvs_.Delete(key));
   }
 
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs_;
@@ -127,7 +127,7 @@
   std::array<char, 8> value{'v', 'a', 'l', 'u', 'e', '6', '7', '\0'};
 
   for (int i = 0; i < 1000; ++i) {
-    ASSERT_EQ(Status::OK,
+    ASSERT_EQ(Status::Ok(),
               kvs_.Put("The Key!", std::as_bytes(std::span(value))));
   }
 }
@@ -136,7 +136,7 @@
   std::array<char, 7> value{'v', 'a', 'l', 'u', 'e', '6', '\0'};
 
   for (int i = 0; i < 1000; ++i) {
-    ASSERT_EQ(Status::OK,
+    ASSERT_EQ(Status::Ok(),
               kvs_.Put("The Key!", std::as_bytes(std::span(value))));
   }
 }
@@ -146,27 +146,27 @@
 
   for (int i = 0; i < 100; ++i) {
     for (unsigned size = 0; size < value.size(); ++size) {
-      ASSERT_EQ(Status::OK, kvs_.Put("The Key!", i));
+      ASSERT_EQ(Status::Ok(), kvs_.Put("The Key!", i));
     }
   }
 }
 
 TEST_F(EmptyInitializedKvs, PutAndGetByValue_ConvertibleToSpan) {
   constexpr float input[] = {1.0, -3.5};
-  ASSERT_EQ(Status::OK, kvs_.Put("key", input));
+  ASSERT_EQ(Status::Ok(), kvs_.Put("key", input));
 
   float output[2] = {};
-  ASSERT_EQ(Status::OK, kvs_.Get("key", &output));
+  ASSERT_EQ(Status::Ok(), kvs_.Get("key", &output));
   EXPECT_EQ(input[0], output[0]);
   EXPECT_EQ(input[1], output[1]);
 }
 
 TEST_F(EmptyInitializedKvs, PutAndGetByValue_Span) {
   float input[] = {1.0, -3.5};
-  ASSERT_EQ(Status::OK, kvs_.Put("key", std::span(input)));
+  ASSERT_EQ(Status::Ok(), kvs_.Put("key", std::span(input)));
 
   float output[2] = {};
-  ASSERT_EQ(Status::OK, kvs_.Get("key", &output));
+  ASSERT_EQ(Status::Ok(), kvs_.Get("key", &output));
   EXPECT_EQ(input[0], output[0]);
   EXPECT_EQ(input[1], output[1]);
 }
@@ -178,116 +178,117 @@
   };
   const TestStruct input{-1234.5, true};
 
-  ASSERT_EQ(Status::OK, kvs_.Put("key", input));
+  ASSERT_EQ(Status::Ok(), kvs_.Put("key", input));
 
   TestStruct output;
-  ASSERT_EQ(Status::OK, kvs_.Get("key", &output));
+  ASSERT_EQ(Status::Ok(), kvs_.Get("key", &output));
   EXPECT_EQ(input.a, output.a);
   EXPECT_EQ(input.b, output.b);
 }
 
 TEST_F(EmptyInitializedKvs, Get_Simple) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
 
   char value[16];
   auto result = kvs_.Get("Charles", std::as_writable_bytes(std::span(value)));
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(sizeof("Mingus"), result.size());
   EXPECT_STREQ("Mingus", value);
 }
 
 TEST_F(EmptyInitializedKvs, Get_WithOffset) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
 
   char value[16];
   auto result =
       kvs_.Get("Charles", std::as_writable_bytes(std::span(value)), 4);
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(sizeof("Mingus") - 4, result.size());
   EXPECT_STREQ("us", value);
 }
 
 TEST_F(EmptyInitializedKvs, Get_WithOffset_FillBuffer) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
 
   char value[4] = {};
   auto result =
       kvs_.Get("Charles", std::as_writable_bytes(std::span(value, 3)), 1);
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
+  EXPECT_EQ(Status::ResourceExhausted(), result.status());
   EXPECT_EQ(3u, result.size());
   EXPECT_STREQ("ing", value);
 }
 
 TEST_F(EmptyInitializedKvs, Get_WithOffset_PastEnd) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
 
   char value[16];
   auto result = kvs_.Get("Charles",
                          std::as_writable_bytes(std::span(value)),
                          sizeof("Mingus") + 1);
-  EXPECT_EQ(Status::OUT_OF_RANGE, result.status());
+  EXPECT_EQ(Status::OutOfRange(), result.status());
   EXPECT_EQ(0u, result.size());
 }
 
 TEST_F(EmptyInitializedKvs, GetValue) {
-  ASSERT_EQ(Status::OK, kvs_.Put("key", uint32_t(0xfeedbeef)));
+  ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
 
   uint32_t value = 0;
-  EXPECT_EQ(Status::OK, kvs_.Get("key", &value));
+  EXPECT_EQ(Status::Ok(), kvs_.Get("key", &value));
   EXPECT_EQ(uint32_t(0xfeedbeef), value);
 }
 
 TEST_F(EmptyInitializedKvs, GetValue_TooSmall) {
-  ASSERT_EQ(Status::OK, kvs_.Put("key", uint32_t(0xfeedbeef)));
+  ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
 
   uint8_t value = 0;
-  EXPECT_EQ(Status::INVALID_ARGUMENT, kvs_.Get("key", &value));
+  EXPECT_EQ(Status::InvalidArgument(), kvs_.Get("key", &value));
   EXPECT_EQ(0u, value);
 }
 
 TEST_F(EmptyInitializedKvs, GetValue_TooLarge) {
-  ASSERT_EQ(Status::OK, kvs_.Put("key", uint32_t(0xfeedbeef)));
+  ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
 
   uint64_t value = 0;
-  EXPECT_EQ(Status::INVALID_ARGUMENT, kvs_.Get("key", &value));
+  EXPECT_EQ(Status::InvalidArgument(), kvs_.Get("key", &value));
   EXPECT_EQ(0u, value);
 }
 
 TEST_F(EmptyInitializedKvs, Delete_GetDeletedKey_ReturnsNotFound) {
-  ASSERT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("123"))));
-  ASSERT_EQ(Status::OK, kvs_.Delete("kEy"));
+  ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+  ASSERT_EQ(Status::Ok(), kvs_.Delete("kEy"));
 
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("kEy", {}).status());
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.ValueSize("kEy").status());
+  EXPECT_EQ(Status::NotFound(), kvs_.Get("kEy", {}).status());
+  EXPECT_EQ(Status::NotFound(), kvs_.ValueSize("kEy").status());
 }
 
 TEST_F(EmptyInitializedKvs, Delete_AddBackKey_PersistsAfterInitialization) {
-  ASSERT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("123"))));
-  ASSERT_EQ(Status::OK, kvs_.Delete("kEy"));
+  ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+  ASSERT_EQ(Status::Ok(), kvs_.Delete("kEy"));
 
-  EXPECT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("45678"))));
+  EXPECT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("45678"))));
   char data[6] = {};
-  ASSERT_EQ(Status::OK, kvs_.Get("kEy", &data));
+  ASSERT_EQ(Status::Ok(), kvs_.Get("kEy", &data));
   EXPECT_STREQ(data, "45678");
 
   // Ensure that the re-added key is still present after reinitialization.
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> new_kvs(&test_partition,
                                                               default_format);
-  ASSERT_EQ(Status::OK, new_kvs.Init());
+  ASSERT_EQ(Status::Ok(), new_kvs.Init());
 
-  EXPECT_EQ(Status::OK, new_kvs.Put("kEy", std::as_bytes(std::span("45678"))));
+  EXPECT_EQ(Status::Ok(),
+            new_kvs.Put("kEy", std::as_bytes(std::span("45678"))));
   char new_data[6] = {};
-  EXPECT_EQ(Status::OK, new_kvs.Get("kEy", &new_data));
+  EXPECT_EQ(Status::Ok(), new_kvs.Get("kEy", &new_data));
   EXPECT_STREQ(data, "45678");
 }
 
 TEST_F(EmptyInitializedKvs, Delete_AllItems_KvsIsEmpty) {
-  ASSERT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("123"))));
-  ASSERT_EQ(Status::OK, kvs_.Delete("kEy"));
+  ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+  ASSERT_EQ(Status::Ok(), kvs_.Delete("kEy"));
 
   EXPECT_EQ(0u, kvs_.size());
   EXPECT_TRUE(kvs_.empty());
@@ -298,17 +299,17 @@
   constexpr std::string_view key1 = "D4";
   constexpr std::string_view key2 = "dFU6S";
 
-  ASSERT_EQ(Status::OK, kvs_.Put(key1, 1000));
+  ASSERT_EQ(Status::Ok(), kvs_.Put(key1, 1000));
 
-  EXPECT_EQ(Status::ALREADY_EXISTS, kvs_.Put(key2, 999));
+  EXPECT_EQ(Status::AlreadyExists(), kvs_.Put(key2, 999));
 
   int value = 0;
-  EXPECT_EQ(Status::OK, kvs_.Get(key1, &value));
+  EXPECT_EQ(Status::Ok(), kvs_.Get(key1, &value));
   EXPECT_EQ(1000, value);
 
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.Get(key2, &value));
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.ValueSize(key2).status());
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.Delete(key2));
+  EXPECT_EQ(Status::NotFound(), kvs_.Get(key2, &value));
+  EXPECT_EQ(Status::NotFound(), kvs_.ValueSize(key2).status());
+  EXPECT_EQ(Status::NotFound(), kvs_.Delete(key2));
 }
 
 TEST_F(EmptyInitializedKvs, Collision_WithDeletedKey) {
@@ -316,18 +317,18 @@
   constexpr std::string_view key1 = "1U2";
   constexpr std::string_view key2 = "ahj9d";
 
-  ASSERT_EQ(Status::OK, kvs_.Put(key1, 1000));
-  ASSERT_EQ(Status::OK, kvs_.Delete(key1));
+  ASSERT_EQ(Status::Ok(), kvs_.Put(key1, 1000));
+  ASSERT_EQ(Status::Ok(), kvs_.Delete(key1));
 
   // key2 collides with key1's tombstone.
-  EXPECT_EQ(Status::ALREADY_EXISTS, kvs_.Put(key2, 999));
+  EXPECT_EQ(Status::AlreadyExists(), kvs_.Put(key2, 999));
 
   int value = 0;
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.Get(key1, &value));
+  EXPECT_EQ(Status::NotFound(), kvs_.Get(key1, &value));
 
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.Get(key2, &value));
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.ValueSize(key2).status());
-  EXPECT_EQ(Status::NOT_FOUND, kvs_.Delete(key2));
+  EXPECT_EQ(Status::NotFound(), kvs_.Get(key2, &value));
+  EXPECT_EQ(Status::NotFound(), kvs_.ValueSize(key2).status());
+  EXPECT_EQ(Status::NotFound(), kvs_.Delete(key2));
 }
 
 TEST_F(EmptyInitializedKvs, Iteration_Empty_ByReference) {
@@ -345,62 +346,63 @@
 }
 
 TEST_F(EmptyInitializedKvs, Iteration_OneItem) {
-  ASSERT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+  ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
 
   for (KeyValueStore::Item entry : kvs_) {
     EXPECT_STREQ(entry.key(), "kEy");  // Make sure null-terminated.
 
     char temp[sizeof("123")] = {};
-    EXPECT_EQ(Status::OK, entry.Get(&temp));
+    EXPECT_EQ(Status::Ok(), entry.Get(&temp));
     EXPECT_STREQ("123", temp);
   }
 }
 
 TEST_F(EmptyInitializedKvs, Iteration_GetWithOffset) {
-  ASSERT_EQ(Status::OK, kvs_.Put("key", std::as_bytes(std::span("not bad!"))));
+  ASSERT_EQ(Status::Ok(),
+            kvs_.Put("key", std::as_bytes(std::span("not bad!"))));
 
   for (KeyValueStore::Item entry : kvs_) {
     char temp[5];
     auto result = entry.Get(std::as_writable_bytes(std::span(temp)), 4);
-    EXPECT_EQ(Status::OK, result.status());
+    EXPECT_EQ(Status::Ok(), result.status());
     EXPECT_EQ(5u, result.size());
     EXPECT_STREQ("bad!", temp);
   }
 }
 
 TEST_F(EmptyInitializedKvs, Iteration_GetValue) {
-  ASSERT_EQ(Status::OK, kvs_.Put("key", uint32_t(0xfeedbeef)));
+  ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
 
   for (KeyValueStore::Item entry : kvs_) {
     uint32_t value = 0;
-    EXPECT_EQ(Status::OK, entry.Get(&value));
+    EXPECT_EQ(Status::Ok(), entry.Get(&value));
     EXPECT_EQ(uint32_t(0xfeedbeef), value);
   }
 }
 
 TEST_F(EmptyInitializedKvs, Iteration_GetValue_TooSmall) {
-  ASSERT_EQ(Status::OK, kvs_.Put("key", uint32_t(0xfeedbeef)));
+  ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
 
   for (KeyValueStore::Item entry : kvs_) {
     uint8_t value = 0;
-    EXPECT_EQ(Status::INVALID_ARGUMENT, entry.Get(&value));
+    EXPECT_EQ(Status::InvalidArgument(), entry.Get(&value));
     EXPECT_EQ(0u, value);
   }
 }
 
 TEST_F(EmptyInitializedKvs, Iteration_GetValue_TooLarge) {
-  ASSERT_EQ(Status::OK, kvs_.Put("key", uint32_t(0xfeedbeef)));
+  ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
 
   for (KeyValueStore::Item entry : kvs_) {
     uint64_t value = 0;
-    EXPECT_EQ(Status::INVALID_ARGUMENT, entry.Get(&value));
+    EXPECT_EQ(Status::InvalidArgument(), entry.Get(&value));
     EXPECT_EQ(0u, value);
   }
 }
 
 TEST_F(EmptyInitializedKvs, Iteration_EmptyAfterDeletion) {
-  ASSERT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("123"))));
-  ASSERT_EQ(Status::OK, kvs_.Delete("kEy"));
+  ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+  ASSERT_EQ(Status::Ok(), kvs_.Delete("kEy"));
 
   for (KeyValueStore::Item entry : kvs_) {
     static_cast<void>(entry);
@@ -423,10 +425,10 @@
   std::memset(buf2, 2, sizeof(buf2));
 
   // Start with things in KVS
-  ASSERT_EQ(Status::OK, kvs_.Put(key1, buf1));
-  ASSERT_EQ(Status::OK, kvs_.Put(key2, buf2));
+  ASSERT_EQ(Status::Ok(), kvs_.Put(key1, buf1));
+  ASSERT_EQ(Status::Ok(), kvs_.Put(key2, buf2));
   for (size_t j = 0; j < keys.size(); j++) {
-    ASSERT_EQ(Status::OK, kvs_.Put(keys[j], j));
+    ASSERT_EQ(Status::Ok(), kvs_.Put(keys[j], j));
   }
 
   for (size_t i = 0; i < 100; i++) {
@@ -435,28 +437,28 @@
     size_t size2 = (kLargestBufSize) / (100 - i);
     for (size_t j = 0; j < 50; j++) {
       // Rewrite a single key many times, can fill up a sector
-      ASSERT_EQ(Status::OK, kvs_.Put("some_data", j));
+      ASSERT_EQ(Status::Ok(), kvs_.Put("some_data", j));
     }
     // Delete and re-add everything
-    ASSERT_EQ(Status::OK, kvs_.Delete(key1));
-    ASSERT_EQ(Status::OK, kvs_.Put(key1, std::span(buf1, size1)));
-    ASSERT_EQ(Status::OK, kvs_.Delete(key2));
-    ASSERT_EQ(Status::OK, kvs_.Put(key2, std::span(buf2, size2)));
+    ASSERT_EQ(Status::Ok(), kvs_.Delete(key1));
+    ASSERT_EQ(Status::Ok(), kvs_.Put(key1, std::span(buf1, size1)));
+    ASSERT_EQ(Status::Ok(), kvs_.Delete(key2));
+    ASSERT_EQ(Status::Ok(), kvs_.Put(key2, std::span(buf2, size2)));
     for (size_t j = 0; j < keys.size(); j++) {
-      ASSERT_EQ(Status::OK, kvs_.Delete(keys[j]));
-      ASSERT_EQ(Status::OK, kvs_.Put(keys[j], j));
+      ASSERT_EQ(Status::Ok(), kvs_.Delete(keys[j]));
+      ASSERT_EQ(Status::Ok(), kvs_.Put(keys[j], j));
     }
 
     // Re-enable and verify
-    ASSERT_EQ(Status::OK, kvs_.Init());
+    ASSERT_EQ(Status::Ok(), kvs_.Init());
     static byte buf[4 * 1024];
-    ASSERT_EQ(Status::OK, kvs_.Get(key1, std::span(buf, size1)).status());
+    ASSERT_EQ(Status::Ok(), kvs_.Get(key1, std::span(buf, size1)).status());
     ASSERT_EQ(std::memcmp(buf, buf1, size1), 0);
-    ASSERT_EQ(Status::OK, kvs_.Get(key2, std::span(buf, size2)).status());
+    ASSERT_EQ(Status::Ok(), kvs_.Get(key2, std::span(buf, size2)).status());
     ASSERT_EQ(std::memcmp(buf2, buf2, size2), 0);
     for (size_t j = 0; j < keys.size(); j++) {
       size_t ret = 1000;
-      ASSERT_EQ(Status::OK, kvs_.Get(keys[j], &ret));
+      ASSERT_EQ(Status::Ok(), kvs_.Get(keys[j], &ret));
       ASSERT_EQ(ret, j);
     }
   }
@@ -466,28 +468,28 @@
   // Add some data
   uint8_t value1 = 0xDA;
   ASSERT_EQ(
-      Status::OK,
+      Status::Ok(),
       kvs_.Put(keys[0], std::as_bytes(std::span(&value1, sizeof(value1)))));
 
   uint32_t value2 = 0xBAD0301f;
-  ASSERT_EQ(Status::OK, kvs_.Put(keys[1], value2));
+  ASSERT_EQ(Status::Ok(), kvs_.Put(keys[1], value2));
 
   // Verify data
   uint32_t test2;
-  EXPECT_EQ(Status::OK, kvs_.Get(keys[1], &test2));
+  EXPECT_EQ(Status::Ok(), kvs_.Get(keys[1], &test2));
   uint8_t test1;
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[0], &test1));
+  ASSERT_EQ(Status::Ok(), kvs_.Get(keys[0], &test1));
 
   EXPECT_EQ(test1, value1);
   EXPECT_EQ(test2, value2);
 
   // Delete a key
-  EXPECT_EQ(Status::OK, kvs_.Delete(keys[0]));
+  EXPECT_EQ(Status::Ok(), kvs_.Delete(keys[0]));
 
   // Verify it was erased
-  EXPECT_EQ(kvs_.Get(keys[0], &test1), Status::NOT_FOUND);
+  EXPECT_EQ(kvs_.Get(keys[0], &test1), Status::NotFound());
   test2 = 0;
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             kvs_.Get(keys[1],
                      std::span(reinterpret_cast<byte*>(&test2), sizeof(test2)))
                 .status());
diff --git a/pw_kvs/key_value_store_map_test.cc b/pw_kvs/key_value_store_map_test.cc
index 87d0dee..27b961c 100644
--- a/pw_kvs/key_value_store_map_test.cc
+++ b/pw_kvs/key_value_store_map_test.cc
@@ -88,9 +88,9 @@
         // For KVS magic value always use a random 32 bit integer rather than a
         // human readable 4 bytes. See pw_kvs/format.h for more information.
         kvs_(&partition_, {.magic = 0xc857e51d, .checksum = nullptr}) {
-    EXPECT_EQ(Status::OK, partition_.Erase());
+    EXPECT_EQ(Status::Ok(), partition_.Erase());
     Status result = kvs_.Init();
-    EXPECT_EQ(Status::OK, result);
+    EXPECT_EQ(Status::Ok(), result);
 
     if (!result.ok()) {
       std::abort();
@@ -250,7 +250,7 @@
         EXPECT_EQ(map_entry->first, item.key());
 
         char value[kMaxValueLength + 1] = {};
-        EXPECT_EQ(Status::OK,
+        EXPECT_EQ(Status::Ok(),
                   item.Get(std::as_writable_bytes(std::span(value))).status());
         EXPECT_EQ(map_entry->second, std::string(value));
       }
@@ -267,10 +267,10 @@
     Status result = kvs_.Put(key, std::as_bytes(std::span(value)));
 
     if (key.empty() || key.size() > internal::Entry::kMaxKeyLength) {
-      EXPECT_EQ(Status::INVALID_ARGUMENT, result);
+      EXPECT_EQ(Status::InvalidArgument(), result);
     } else if (map_.size() == kvs_.max_size()) {
-      EXPECT_EQ(Status::RESOURCE_EXHAUSTED, result);
-    } else if (result == Status::RESOURCE_EXHAUSTED) {
+      EXPECT_EQ(Status::ResourceExhausted(), result);
+    } else if (result == Status::ResourceExhausted()) {
       EXPECT_FALSE(map_.empty());
     } else if (result.ok()) {
       map_[key] = value;
@@ -290,9 +290,9 @@
     Status result = kvs_.Delete(key);
 
     if (key.empty() || key.size() > internal::Entry::kMaxKeyLength) {
-      EXPECT_EQ(Status::INVALID_ARGUMENT, result);
+      EXPECT_EQ(Status::InvalidArgument(), result);
     } else if (map_.count(key) == 0) {
-      EXPECT_EQ(Status::NOT_FOUND, result);
+      EXPECT_EQ(Status::NotFound(), result);
     } else if (result.ok()) {
       map_.erase(key);
 
@@ -302,7 +302,7 @@
       }
 
       deleted_.insert(key);
-    } else if (result == Status::RESOURCE_EXHAUSTED) {
+    } else if (result == Status::ResourceExhausted()) {
       PW_LOG_WARN("Delete: RESOURCE_EXHAUSTED could not delete key %s",
                   key.c_str());
     } else {
@@ -315,14 +315,14 @@
   void Init() {
     StartOperation("Init");
     Status status = kvs_.Init();
-    EXPECT_EQ(Status::OK, status);
+    EXPECT_EQ(Status::Ok(), status);
     FinishOperation("Init", status);
   }
 
   void GCFull() {
     StartOperation("GCFull");
     Status status = kvs_.FullMaintenance();
-    EXPECT_EQ(Status::OK, status);
+    EXPECT_EQ(Status::Ok(), status);
 
     KeyValueStore::StorageStats post_stats = kvs_.GetStorageStats();
     if (post_stats.in_use_bytes > ((partition_.size_bytes() * 70) / 100)) {
@@ -338,10 +338,10 @@
     Status status = kvs_.PartialMaintenance();
     KeyValueStore::StorageStats post_stats = kvs_.GetStorageStats();
     if (pre_stats.reclaimable_bytes != 0) {
-      EXPECT_EQ(Status::OK, status);
+      EXPECT_EQ(Status::Ok(), status);
       EXPECT_LT(post_stats.reclaimable_bytes, pre_stats.reclaimable_bytes);
     } else {
-      EXPECT_EQ(Status::NOT_FOUND, status);
+      EXPECT_EQ(Status::NotFound(), status);
       EXPECT_EQ(post_stats.reclaimable_bytes, 0U);
     }
     FinishOperation("GCPartial", status);
diff --git a/pw_kvs/key_value_store_test.cc b/pw_kvs/key_value_store_test.cc
index e02aa91..2820793 100644
--- a/pw_kvs/key_value_store_test.cc
+++ b/pw_kvs/key_value_store_test.cc
@@ -121,12 +121,12 @@
     std::FILE* out_file = std::fopen(filename, "w+");
     if (out_file == nullptr) {
       PW_LOG_ERROR("Failed to dump to %s", filename);
-      return Status::DATA_LOSS;
+      return Status::DataLoss();
     }
     std::vector<std::byte> out_vec(memory.size_bytes());
     Status status =
         memory.Read(0, std::span<std::byte>(out_vec.data(), out_vec.size()));
-    if (status != Status::OK) {
+    if (status != Status::Ok()) {
       fclose(out_file);
       return status;
     }
@@ -137,17 +137,17 @@
       PW_LOG_ERROR("Failed to dump to %s, written=%u",
                    filename,
                    static_cast<unsigned>(written));
-      status = Status::DATA_LOSS;
+      status = Status::DataLoss();
     } else {
       PW_LOG_INFO("Dumped to %s", filename);
-      status = Status::OK;
+      status = Status::Ok();
     }
 
     fclose(out_file);
     return status;
   }
 #else
-  Status Dump(const char*) { return Status::OK; }
+  Status Dump(const char*) { return Status::Ok(); }
 #endif  // DUMP_KVS_STATE_TO_FILE
 };
 
@@ -179,7 +179,7 @@
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs(&test_partition,
                                                           format);
 
-  EXPECT_EQ(kvs.Init(), Status::FAILED_PRECONDITION);
+  EXPECT_EQ(kvs.Init(), Status::FailedPrecondition());
 }
 
 TEST(InitCheck, ZeroSectors) {
@@ -195,7 +195,7 @@
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs(&test_partition,
                                                           format);
 
-  EXPECT_EQ(kvs.Init(), Status::FAILED_PRECONDITION);
+  EXPECT_EQ(kvs.Init(), Status::FailedPrecondition());
 }
 
 TEST(InitCheck, TooManySectors) {
@@ -210,11 +210,11 @@
   constexpr EntryFormat format{.magic = 0x610f6d17, .checksum = nullptr};
   KeyValueStoreBuffer<kMaxEntries, 2> kvs(&test_partition, format);
 
-  EXPECT_EQ(kvs.Init(), Status::FAILED_PRECONDITION);
+  EXPECT_EQ(kvs.Init(), Status::FailedPrecondition());
 }
 
-#define ASSERT_OK(expr) ASSERT_EQ(Status::OK, expr)
-#define EXPECT_OK(expr) EXPECT_EQ(Status::OK, expr)
+#define ASSERT_OK(expr) ASSERT_EQ(Status::Ok(), expr)
+#define EXPECT_OK(expr) EXPECT_EQ(Status::Ok(), expr)
 
 TEST(InMemoryKvs, WriteOneKeyMultipleTimes) {
   // Create and erase the fake flash. It will persist across reloads.
@@ -358,7 +358,7 @@
 
   // Create and erase the fake flash.
   Flash flash;
-  ASSERT_EQ(Status::OK, flash.partition.Erase());
+  ASSERT_EQ(Status::Ok(), flash.partition.Erase());
 
   // Create and initialize the KVS.
   // For KVS magic value always use a random 32 bit integer rather than a
@@ -393,7 +393,7 @@
 TEST(InMemoryKvs, CallingEraseTwice_NothingWrittenToFlash) {
   // Create and erase the fake flash.
   Flash flash;
-  ASSERT_EQ(Status::OK, flash.partition.Erase());
+  ASSERT_EQ(Status::Ok(), flash.partition.Erase());
 
   // Create and initialize the KVS.
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs(&flash.partition,
@@ -401,13 +401,13 @@
   ASSERT_OK(kvs.Init());
 
   const uint8_t kValue = 0xDA;
-  ASSERT_EQ(Status::OK, kvs.Put(keys[0], kValue));
-  ASSERT_EQ(Status::OK, kvs.Delete(keys[0]));
+  ASSERT_EQ(Status::Ok(), kvs.Put(keys[0], kValue));
+  ASSERT_EQ(Status::Ok(), kvs.Delete(keys[0]));
 
   // Compare before / after checksums to verify that nothing was written.
   const uint16_t crc = checksum::Crc16Ccitt::Calculate(flash.memory.buffer());
 
-  EXPECT_EQ(kvs.Delete(keys[0]), Status::NOT_FOUND);
+  EXPECT_EQ(kvs.Delete(keys[0]), Status::NotFound());
 
   EXPECT_EQ(crc, checksum::Crc16Ccitt::Calculate(flash.memory.buffer()));
 }
@@ -415,8 +415,8 @@
 class LargeEmptyInitializedKvs : public ::testing::Test {
  protected:
   LargeEmptyInitializedKvs() : kvs_(&large_test_partition, default_format) {
-    ASSERT_EQ(Status::OK, large_test_partition.Erase());
-    ASSERT_EQ(Status::OK, kvs_.Init());
+    ASSERT_EQ(Status::Ok(), large_test_partition.Erase());
+    ASSERT_EQ(Status::Ok(), kvs_.Init());
   }
 
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs_;
@@ -426,23 +426,23 @@
   const uint8_t kValue1 = 0xDA;
   const uint8_t kValue2 = 0x12;
   uint8_t value;
-  ASSERT_EQ(Status::OK, kvs_.Put(keys[0], kValue1));
+  ASSERT_EQ(Status::Ok(), kvs_.Put(keys[0], kValue1));
   EXPECT_EQ(kvs_.size(), 1u);
-  ASSERT_EQ(Status::OK, kvs_.Delete(keys[0]));
-  EXPECT_EQ(kvs_.Get(keys[0], &value), Status::NOT_FOUND);
-  ASSERT_EQ(Status::OK, kvs_.Put(keys[1], kValue1));
-  ASSERT_EQ(Status::OK, kvs_.Put(keys[2], kValue2));
-  ASSERT_EQ(Status::OK, kvs_.Delete(keys[1]));
-  EXPECT_EQ(Status::OK, kvs_.Get(keys[2], &value));
+  ASSERT_EQ(Status::Ok(), kvs_.Delete(keys[0]));
+  EXPECT_EQ(kvs_.Get(keys[0], &value), Status::NotFound());
+  ASSERT_EQ(Status::Ok(), kvs_.Put(keys[1], kValue1));
+  ASSERT_EQ(Status::Ok(), kvs_.Put(keys[2], kValue2));
+  ASSERT_EQ(Status::Ok(), kvs_.Delete(keys[1]));
+  EXPECT_EQ(Status::Ok(), kvs_.Get(keys[2], &value));
   EXPECT_EQ(kValue2, value);
-  ASSERT_EQ(kvs_.Get(keys[1], &value), Status::NOT_FOUND);
+  ASSERT_EQ(kvs_.Get(keys[1], &value), Status::NotFound());
   EXPECT_EQ(kvs_.size(), 1u);
 }
 
 TEST(InMemoryKvs, Put_MaxValueSize) {
   // Create and erase the fake flash.
   Flash flash;
-  ASSERT_EQ(Status::OK, flash.partition.Erase());
+  ASSERT_EQ(Status::Ok(), flash.partition.Erase());
 
   // Create and initialize the KVS.
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs(&flash.partition,
@@ -462,12 +462,12 @@
   ASSERT_GT(sizeof(large_test_flash), max_value_size + 2 * sizeof(EntryHeader));
   auto big_data = std::as_bytes(std::span(&large_test_flash, 1));
 
-  EXPECT_EQ(Status::OK, kvs.Put("K", big_data.subspan(0, max_value_size)));
+  EXPECT_EQ(Status::Ok(), kvs.Put("K", big_data.subspan(0, max_value_size)));
 
   // Larger than maximum is rejected.
-  EXPECT_EQ(Status::INVALID_ARGUMENT,
+  EXPECT_EQ(Status::InvalidArgument(),
             kvs.Put("K", big_data.subspan(0, max_value_size + 1)));
-  EXPECT_EQ(Status::INVALID_ARGUMENT, kvs.Put("K", big_data));
+  EXPECT_EQ(Status::InvalidArgument(), kvs.Put("K", big_data));
 }
 
 }  // namespace pw::kvs
diff --git a/pw_kvs/key_value_store_wear_test.cc b/pw_kvs/key_value_store_wear_test.cc
index d6cadc4..d272535 100644
--- a/pw_kvs/key_value_store_wear_test.cc
+++ b/pw_kvs/key_value_store_wear_test.cc
@@ -35,7 +35,7 @@
       : flash_(internal::Entry::kMinAlignmentBytes),
         partition_(&flash_, 0, flash_.sector_count()),
         kvs_(&partition_, format) {
-    EXPECT_EQ(Status::OK, kvs_.Init());
+    EXPECT_EQ(Status::Ok(), kvs_.Init());
   }
 
   static constexpr size_t kSectors = 16;
@@ -92,7 +92,7 @@
     test_data[0]++;
 
     EXPECT_EQ(
-        Status::OK,
+        Status::Ok(),
         kvs_.Put("key",
                  std::as_bytes(std::span(test_data, sizeof(test_data) - 70))));
   }
@@ -105,7 +105,7 @@
     test_data[0]++;
 
     printf("Add entry %zu\n", i);
-    EXPECT_EQ(Status::OK, kvs_.Put("big_key", test_data));
+    EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
   }
 
   EXPECT_EQ(2u, kvs_.size());
diff --git a/pw_kvs/public/pw_kvs/alignment.h b/pw_kvs/public/pw_kvs/alignment.h
index e8cf191..56d0c08 100644
--- a/pw_kvs/public/pw_kvs/alignment.h
+++ b/pw_kvs/public/pw_kvs/alignment.h
@@ -116,7 +116,7 @@
   // TODO: This should convert to PW_CHECK once that is available for use in
   // host tests.
   if (alignment_bytes > kBufferSize) {
-    return StatusWithSize::INTERNAL;
+    return StatusWithSize::Internal();
   }
 
   AlignedWriterBuffer<kBufferSize> buffer(alignment_bytes, output);
diff --git a/pw_kvs/public/pw_kvs/fake_flash_memory.h b/pw_kvs/public/pw_kvs/fake_flash_memory.h
index c1b0bbe..9795e01 100644
--- a/pw_kvs/public/pw_kvs/fake_flash_memory.h
+++ b/pw_kvs/public/pw_kvs/fake_flash_memory.h
@@ -97,9 +97,9 @@
         write_errors_(write_errors) {}
 
   // The fake flash is always enabled.
-  Status Enable() override { return Status::OK; }
+  Status Enable() override { return Status::Ok(); }
 
-  Status Disable() override { return Status::OK; }
+  Status Disable() override { return Status::Ok(); }
 
   bool IsEnabled() const override { return true; }
 
diff --git a/pw_kvs/public/pw_kvs/flash_memory.h b/pw_kvs/public/pw_kvs/flash_memory.h
index a486889..029fba2 100644
--- a/pw_kvs/public/pw_kvs/flash_memory.h
+++ b/pw_kvs/public/pw_kvs/flash_memory.h
@@ -59,7 +59,7 @@
 
   virtual bool IsEnabled() const = 0;
 
-  virtual Status SelfTest() { return Status::UNIMPLEMENTED; }
+  virtual Status SelfTest() { return Status::Unimplemented(); }
 
   // Erase num_sectors starting at a given address. Blocking call.
   // Address should be on a sector boundary. Returns:
@@ -199,7 +199,7 @@
   virtual ~FlashPartition() = default;
 
   // Performs any required partition or flash-level initialization.
-  virtual Status Init() { return Status::OK; }
+  virtual Status Init() { return Status::Ok(); }
 
   // Erase num_sectors starting at a given address. Blocking call.
   // Address must be on a sector boundary. Returns:
diff --git a/pw_kvs/public/pw_kvs/io.h b/pw_kvs/public/pw_kvs/io.h
index 167182f..80a0ef0 100644
--- a/pw_kvs/public/pw_kvs/io.h
+++ b/pw_kvs/public/pw_kvs/io.h
@@ -71,7 +71,7 @@
 
 // Output adapter that calls a method on a class with a std::span of bytes. If
 // the method returns void instead of the expected Status, Write always returns
-// Status::OK.
+// Status::Ok().
 template <auto kMethod>
 class OutputToMethod final : public Output {
   using Class = typename internal::FunctionTraits<decltype(kMethod)>::Class;
diff --git a/pw_kvs/sectors.cc b/pw_kvs/sectors.cc
index 7377a11..94ff16e 100644
--- a/pw_kvs/sectors.cc
+++ b/pw_kvs/sectors.cc
@@ -108,7 +108,7 @@
       if ((find_mode == kAppendEntry) ||
           (sector->RecoverableBytes(sector_size_bytes) == 0)) {
         *found_sector = sector;
-        return Status::OK;
+        return Status::Ok();
       } else {
         if ((non_empty_least_reclaimable_sector == nullptr) ||
             (non_empty_least_reclaimable_sector->RecoverableBytes(
@@ -137,7 +137,7 @@
         Index(first_empty_sector));
     last_new_ = first_empty_sector;
     *found_sector = first_empty_sector;
-    return Status::OK;
+    return Status::Ok();
   }
 
   // Tier 3 check: If we got this far, use the sector with least recoverable
@@ -147,13 +147,13 @@
     DBG("  Found a usable sector %u, with %u B recoverable, in GC",
         Index(*found_sector),
         unsigned((*found_sector)->RecoverableBytes(sector_size_bytes)));
-    return Status::OK;
+    return Status::Ok();
   }
 
   // No sector was found.
   DBG("  Unable to find a usable sector");
   *found_sector = nullptr;
-  return Status::RESOURCE_EXHAUSTED;
+  return Status::ResourceExhausted();
 }
 
 SectorDescriptor& Sectors::WearLeveledSectorFromIndex(size_t idx) const {
diff --git a/pw_kvs/test_key_value_store_test.cc b/pw_kvs/test_key_value_store_test.cc
index 5219925..af6d4a9 100644
--- a/pw_kvs/test_key_value_store_test.cc
+++ b/pw_kvs/test_key_value_store_test.cc
@@ -24,10 +24,10 @@
 // Simple test to verify that the TestKvs() does basic function.
 TEST(TestKvs, PutGetValue) {
   KeyValueStore& kvs = TestKvs();
-  ASSERT_EQ(Status::OK, kvs.Put("key", uint32_t(0xfeedbeef)));
+  ASSERT_EQ(Status::Ok(), kvs.Put("key", uint32_t(0xfeedbeef)));
 
   uint32_t value = 0;
-  EXPECT_EQ(Status::OK, kvs.Get("key", &value));
+  EXPECT_EQ(Status::Ok(), kvs.Get("key", &value));
   EXPECT_EQ(uint32_t(0xfeedbeef), value);
 }