diff --git a/pw_allocator/block.cc b/pw_allocator/block.cc
index 6b7b7fd..67b0a7b 100644
--- a/pw_allocator/block.cc
+++ b/pw_allocator/block.cc
@@ -21,11 +21,11 @@
 Status Block::Init(const std::span<std::byte> region, Block** block) {
   // Ensure the region we're given is aligned and sized accordingly
   if (reinterpret_cast<uintptr_t>(region.data()) % alignof(Block) != 0) {
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
 
   if (region.size() < sizeof(Block)) {
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
 
   union {
@@ -46,18 +46,18 @@
 #if PW_ALLOCATOR_POISON_ENABLE
   (*block)->PoisonBlock();
 #endif  // PW_ALLOCATOR_POISON_ENABLE
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status Block::Split(size_t head_block_inner_size, Block** new_block) {
   if (new_block == nullptr) {
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
 
   // Don't split used blocks.
   // TODO: Relax this restriction? Flag to enable/disable this check?
   if (Used()) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
 
   // First round the head_block_inner_size up to a alignof(Block) bounary.
@@ -74,7 +74,7 @@
   // (1) Are we trying to allocate a head block larger than the current head
   // block? This may happen because of the alignment above.
   if (aligned_head_block_inner_size > InnerSize()) {
-    return Status::OUT_OF_RANGE;
+    return Status::OutOfRange();
   }
 
   // (2) Does the resulting block have enough space to store the header?
@@ -82,7 +82,7 @@
   // size == sizeof(Block))?
   if (InnerSize() - aligned_head_block_inner_size <
       sizeof(Block) + 2 * PW_ALLOCATOR_POISON_OFFSET) {
-    return Status::RESOURCE_EXHAUSTED;
+    return Status::ResourceExhausted();
   }
 
   // Create the new block inside the current one.
@@ -118,18 +118,18 @@
   (*new_block)->PoisonBlock();
 #endif  // PW_ALLOCATOR_POISON_ENABLE
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status Block::MergeNext() {
   // Anything to merge with?
   if (Last()) {
-    return Status::OUT_OF_RANGE;
+    return Status::OutOfRange();
   }
 
   // Is this or the next block in use?
   if (Used() || Next()->Used()) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
 
   // Simply enough, this block's next pointer becomes the next block's
@@ -142,14 +142,14 @@
     Next()->prev = this;
   }
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status Block::MergePrev() {
   // We can't merge if we have no previous. After that though, merging with
   // the previous block is just MergeNext from the previous block.
   if (prev == nullptr) {
-    return Status::OUT_OF_RANGE;
+    return Status::OutOfRange();
   }
 
   // WARNING: This class instance will still exist, but technically be invalid
diff --git a/pw_allocator/block_test.cc b/pw_allocator/block_test.cc
index c71cd38..0fd5d39 100644
--- a/pw_allocator/block_test.cc
+++ b/pw_allocator/block_test.cc
@@ -30,7 +30,7 @@
   Block* block = nullptr;
   auto status = Block::Init(std::span(bytes, kN), &block);
 
-  ASSERT_EQ(status, Status::OK);
+  ASSERT_EQ(status, Status::Ok());
   EXPECT_EQ(block->OuterSize(), kN);
   EXPECT_EQ(block->InnerSize(),
             kN - sizeof(Block) - 2 * PW_ALLOCATOR_POISON_OFFSET);
@@ -50,7 +50,7 @@
   Block* block = nullptr;
   auto status = Block::Init(std::span(byte_ptr + 1, kN - 1), &block);
 
-  EXPECT_EQ(status, Status::INVALID_ARGUMENT);
+  EXPECT_EQ(status, Status::InvalidArgument());
 }
 
 TEST(Block, CannotCreateTooSmallBlock) {
@@ -59,7 +59,7 @@
   Block* block = nullptr;
   auto status = Block::Init(std::span(bytes, kN), &block);
 
-  EXPECT_EQ(status, Status::INVALID_ARGUMENT);
+  EXPECT_EQ(status, Status::InvalidArgument());
 }
 
 TEST(Block, CanSplitBlock) {
@@ -73,7 +73,7 @@
   Block* next_block = nullptr;
   auto status = block->Split(kSplitN, &next_block);
 
-  ASSERT_EQ(status, Status::OK);
+  ASSERT_EQ(status, Status::Ok());
   EXPECT_EQ(block->InnerSize(), kSplitN);
   EXPECT_EQ(block->OuterSize(),
             kSplitN + sizeof(Block) + 2 * PW_ALLOCATOR_POISON_OFFSET);
@@ -106,7 +106,7 @@
   Block* next_block = nullptr;
   auto status = block->Split(kSplitN, &next_block);
 
-  ASSERT_EQ(status, Status::OK);
+  ASSERT_EQ(status, Status::Ok());
   EXPECT_EQ(block->InnerSize(), split_len);
   EXPECT_EQ(block->OuterSize(),
             split_len + sizeof(Block) + 2 * PW_ALLOCATOR_POISON_OFFSET);
@@ -159,7 +159,7 @@
   Block* next_block = nullptr;
   auto status = block->Split(kSplitN, &next_block);
 
-  EXPECT_EQ(status, Status::RESOURCE_EXHAUSTED);
+  EXPECT_EQ(status, Status::ResourceExhausted());
   EXPECT_EQ(next_block, nullptr);
 }
 
@@ -172,7 +172,7 @@
   Block::Init(std::span(bytes, kN), &block);
 
   auto status = block->Split(kSplitN, nullptr);
-  EXPECT_EQ(status, Status::INVALID_ARGUMENT);
+  EXPECT_EQ(status, Status::InvalidArgument());
 }
 
 TEST(Block, CannotMakeBlockLargerInSplit) {
@@ -186,7 +186,7 @@
   Block* next_block = nullptr;
   auto status = block->Split(block->InnerSize() + 1, &next_block);
 
-  EXPECT_EQ(status, Status::OUT_OF_RANGE);
+  EXPECT_EQ(status, Status::OutOfRange());
 }
 
 TEST(Block, CannotMakeSecondBlockLargerInSplit) {
@@ -202,7 +202,7 @@
       block->InnerSize() - sizeof(Block) - 2 * PW_ALLOCATOR_POISON_OFFSET + 1,
       &next_block);
 
-  ASSERT_EQ(status, Status::RESOURCE_EXHAUSTED);
+  ASSERT_EQ(status, Status::ResourceExhausted());
   EXPECT_EQ(next_block, nullptr);
 }
 
@@ -217,7 +217,7 @@
   Block* next_block = nullptr;
   auto status = block->Split(0, &next_block);
 
-  ASSERT_EQ(status, Status::OK);
+  ASSERT_EQ(status, Status::Ok());
   EXPECT_EQ(block->InnerSize(), static_cast<size_t>(0));
 }
 
@@ -234,7 +234,7 @@
       block->InnerSize() - sizeof(Block) - 2 * PW_ALLOCATOR_POISON_OFFSET,
       &next_block);
 
-  ASSERT_EQ(status, Status::OK);
+  ASSERT_EQ(status, Status::Ok());
   EXPECT_EQ(next_block->InnerSize(), static_cast<size_t>(0));
 }
 
@@ -267,7 +267,7 @@
 
   Block* next_block = nullptr;
   auto status = block->Split(512, &next_block);
-  EXPECT_EQ(status, Status::FAILED_PRECONDITION);
+  EXPECT_EQ(status, Status::FailedPrecondition());
 }
 
 TEST(Block, CanMergeWithNextBlock) {
@@ -287,7 +287,7 @@
   Block* block3 = nullptr;
   block->Split(kSplit2, &block3);
 
-  EXPECT_EQ(block3->MergeNext(), Status::OK);
+  EXPECT_EQ(block3->MergeNext(), Status::Ok());
 
   EXPECT_EQ(block->Next(), block3);
   EXPECT_EQ(block3->Prev(), block);
@@ -312,8 +312,8 @@
   Block* next_block = nullptr;
   block->Split(512, &next_block);
 
-  EXPECT_EQ(next_block->MergeNext(), Status::OUT_OF_RANGE);
-  EXPECT_EQ(block->MergePrev(), Status::OUT_OF_RANGE);
+  EXPECT_EQ(next_block->MergeNext(), Status::OutOfRange());
+  EXPECT_EQ(block->MergePrev(), Status::OutOfRange());
 }
 
 TEST(Block, CannotMergeUsedBlock) {
@@ -329,8 +329,8 @@
   block->Split(512, &next_block);
 
   block->MarkUsed();
-  EXPECT_EQ(block->MergeNext(), Status::FAILED_PRECONDITION);
-  EXPECT_EQ(next_block->MergePrev(), Status::FAILED_PRECONDITION);
+  EXPECT_EQ(block->MergeNext(), Status::FailedPrecondition());
+  EXPECT_EQ(next_block->MergePrev(), Status::FailedPrecondition());
 }
 
 TEST(Block, CanCheckValidBlock) {
diff --git a/pw_allocator/freelist.cc b/pw_allocator/freelist.cc
index 4629a4f..d46e010 100644
--- a/pw_allocator/freelist.cc
+++ b/pw_allocator/freelist.cc
@@ -19,7 +19,7 @@
 Status FreeList::AddChunk(std::span<std::byte> chunk) {
   // Check that the size is enough to actually store what we need
   if (chunk.size() < sizeof(FreeListNode)) {
-    return Status::OUT_OF_RANGE;
+    return Status::OutOfRange();
   }
 
   union {
@@ -36,7 +36,7 @@
   aliased.node->next = chunks_[chunk_ptr];
   chunks_[chunk_ptr] = aliased.node;
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 std::span<std::byte> FreeList::FindChunk(size_t size) const {
@@ -85,14 +85,14 @@
 
   // Check head first.
   if (chunks_[chunk_ptr] == nullptr) {
-    return Status::NOT_FOUND;
+    return Status::NotFound();
   }
 
   aliased.node = chunks_[chunk_ptr];
   if (aliased.data == chunk.data()) {
     chunks_[chunk_ptr] = aliased.node->next;
 
-    return Status::OK;
+    return Status::Ok();
   }
 
   // No? Walk the nodes.
@@ -103,13 +103,13 @@
     if (aliased_next.data == chunk.data()) {
       // Found it, remove this node out of the chain
       aliased.node->next = aliased_next.node->next;
-      return Status::OK;
+      return Status::Ok();
     }
 
     aliased.node = aliased.node->next;
   }
 
-  return Status::NOT_FOUND;
+  return Status::NotFound();
 }
 
 size_t FreeList::FindChunkPtrForSize(size_t size, bool non_null) const {
diff --git a/pw_allocator/freelist_test.cc b/pw_allocator/freelist_test.cc
index 0484a7a..865ea3f 100644
--- a/pw_allocator/freelist_test.cc
+++ b/pw_allocator/freelist_test.cc
@@ -43,7 +43,7 @@
   byte data[kN] = {std::byte(0)};
 
   auto status = list.AddChunk(std::span(data, kN));
-  EXPECT_EQ(status, Status::OK);
+  EXPECT_EQ(status, Status::Ok());
 
   auto item = list.FindChunk(kN);
   EXPECT_EQ(item.size(), kN);
@@ -70,7 +70,7 @@
 
   list.AddChunk(std::span(data, kN));
   auto status = list.RemoveChunk(std::span(data, kN));
-  EXPECT_EQ(status, Status::OK);
+  EXPECT_EQ(status, Status::Ok());
 
   auto item = list.FindChunk(kN);
   EXPECT_EQ(item.size(), static_cast<size_t>(0));
@@ -148,7 +148,7 @@
 
   list.AddChunk(std::span(data, kN));
   auto status = list.RemoveChunk(std::span(data2, kN));
-  EXPECT_EQ(status, Status::NOT_FOUND);
+  EXPECT_EQ(status, Status::NotFound());
 }
 
 TEST(FreeList, CanStoreMultipleChunksPerBucket) {
diff --git a/pw_assert/assert_backend_compile_test.cc b/pw_assert/assert_backend_compile_test.cc
index da19e34..6e1ac2e 100644
--- a/pw_assert/assert_backend_compile_test.cc
+++ b/pw_assert/assert_backend_compile_test.cc
@@ -203,7 +203,7 @@
 
 TEST(Check, CheckOkMacrosCompile) {
   MAYBE_SKIP_TEST;
-  pw::Status status = pw::Status::UNKNOWN;
+  pw::Status status = pw::Status::Unknown();
 
   // Typical case with long names.
   PW_CHECK_OK(status);
@@ -216,10 +216,10 @@
   CHECK_OK(status, "msg: %d", 5);
 
   // Status from a literal.
-  PW_CHECK_OK(pw::Status::OK);
+  PW_CHECK_OK(pw::Status::Ok());
 
   // Status from a function.
-  PW_CHECK_OK(MakeStatus(pw::Status::OK));
+  PW_CHECK_OK(MakeStatus(pw::Status::Ok()));
 
   // Status from C enums.
   PW_CHECK_OK(PW_STATUS_OK);
diff --git a/pw_assert/assert_facade_test.cc b/pw_assert/assert_facade_test.cc
index 34faecb..083d206 100644
--- a/pw_assert/assert_facade_test.cc
+++ b/pw_assert/assert_facade_test.cc
@@ -421,32 +421,32 @@
 
 // When DCHECKs are disabled, they should not trip, and their arguments
 // shouldn't be evaluated.
-TEST(AssertPass, DCheckDisabledSingleSideEffectingCall) {
+TEST(AssertPass, DCheckDisabledSingleSideEffectingCall_1) {
   global_state_for_multi_evaluate_test = 0;
   PW_DCHECK(IncrementsGlobal() == 0);
   EXPECT_EQ(global_state_for_multi_evaluate_test, 0);
 }
-TEST(AssertPass, DCheckDisabledSingleSideEffectingCall) {
+TEST(AssertPass, DCheckDisabledSingleSideEffectingCall_2) {
   global_state_for_multi_evaluate_test = 0;
   PW_DCHECK(IncrementsGlobal() == 1);
   EXPECT_EQ(global_state_for_multi_evaluate_test, 0);
 }
-TEST(AssertPass, DCheckDisabledBinaryOpSingleSideEffectingCall) {
+TEST(AssertPass, DCheckDisabledBinaryOpSingleSideEffectingCall_1) {
   global_state_for_multi_evaluate_test = 0;
   PW_DCHECK_INT_EQ(0, IncrementsGlobal());
   EXPECT_EQ(global_state_for_multi_evaluate_test, 0);
 }
-TEST(AssertPass, DCheckDisabledBinaryOpTwoSideEffectingCalls) {
+TEST(AssertPass, DCheckDisabledBinaryOpTwoSideEffectingCalls_1) {
   global_state_for_multi_evaluate_test = 0;
   PW_DCHECK_INT_EQ(IncrementsGlobal(), IncrementsGlobal());
   EXPECT_EQ(global_state_for_multi_evaluate_test, 0);
 }
-TEST(AssertPass, DCheckDisabledBinaryOpSingleSideEffectingCall) {
+TEST(AssertPass, DCheckDisabledBinaryOpSingleSideEffectingCall_2) {
   global_state_for_multi_evaluate_test = 0;
   PW_DCHECK_INT_EQ(12314, IncrementsGlobal());
   EXPECT_EQ(global_state_for_multi_evaluate_test, 0);
 }
-TEST(AssertPass, DCheckDisabledBinaryOpTwoSideEffectingCalls) {
+TEST(AssertPass, DCheckDisabledBinaryOpTwoSideEffectingCalls_2) {
   global_state_for_multi_evaluate_test = 0;
   PW_DCHECK_INT_EQ(IncrementsGlobal() + 10, IncrementsGlobal());
   EXPECT_EQ(global_state_for_multi_evaluate_test, 0);
@@ -475,25 +475,25 @@
 
 // Verify PW_CHECK_OK, including message handling.
 TEST_F(AssertFail, StatusNotOK) {
-  pw::Status status = pw::Status::UNKNOWN;
+  pw::Status status = pw::Status::Unknown();
   PW_CHECK_OK(status);
   EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == Status::OK (=OK). ");
 }
 
 TEST_F(AssertFail, StatusNotOKMessageNoArguments) {
-  pw::Status status = pw::Status::UNKNOWN;
+  pw::Status status = pw::Status::Unknown();
   PW_CHECK_OK(status, "msg");
   EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == Status::OK (=OK). msg");
 }
 
 TEST_F(AssertFail, StatusNotOKMessageArguments) {
-  pw::Status status = pw::Status::UNKNOWN;
+  pw::Status status = pw::Status::Unknown();
   PW_CHECK_OK(status, "msg: %d", 5);
   EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == Status::OK (=OK). msg: 5");
 }
 
 // Example expression for the test below.
-pw::Status DoTheThing() { return pw::Status::RESOURCE_EXHAUSTED; }
+pw::Status DoTheThing() { return pw::Status::ResourceExhausted(); }
 
 TEST_F(AssertFail, NonTrivialExpression) {
   PW_CHECK_OK(DoTheThing());
@@ -504,32 +504,25 @@
 // Note: This function seems pointless but it is not, since pw::Status::FOO
 // constants are not actually status objects, but code objects. This way we can
 // ensure the macros work with both real status objects and literals.
-pw::Status MakeStatus(pw::Status status) { return status; }
-TEST_F(AssertPass, Constant) { PW_CHECK_OK(pw::Status::OK); }
-TEST_F(AssertPass, Dynamic) { PW_CHECK_OK(MakeStatus(pw::Status::OK)); }
+TEST_F(AssertPass, Function) { PW_CHECK_OK(pw::Status::Ok()); }
 TEST_F(AssertPass, Enum) { PW_CHECK_OK(PW_STATUS_OK); }
-TEST_F(AssertFail, Constant) { PW_CHECK_OK(pw::Status::UNKNOWN); }
-TEST_F(AssertFail, Dynamic) { PW_CHECK_OK(MakeStatus(pw::Status::UNKNOWN)); }
+TEST_F(AssertFail, Function) { PW_CHECK_OK(pw::Status::Unknown()); }
 TEST_F(AssertFail, Enum) { PW_CHECK_OK(PW_STATUS_UNKNOWN); }
 
 #if PW_ASSERT_ENABLE_DEBUG
 
 // In debug mode, the asserts should check their arguments.
-TEST_F(AssertPass, DCheckConstant) { PW_DCHECK_OK(pw::Status::OK); }
-TEST_F(AssertPass, DCheckDynamic) { PW_DCHECK_OK(MakeStatus(pw::Status::OK)); }
-TEST_F(AssertFail, DCheckConstant) { PW_DCHECK_OK(pw::Status::UNKNOWN); }
-TEST_F(AssertFail, DCheckDynamic) {
-  PW_DCHECK_OK(MakeStatus(pw::Status::UNKNOWN));
-}
+TEST_F(AssertPass, DCheckFunction) { PW_DCHECK_OK(pw::Status::Ok()); }
+TEST_F(AssertPass, DCheckEnum) { PW_DCHECK_OK(PW_STATUS_OK); }
+TEST_F(AssertFail, DCheckFunction) { PW_DCHECK_OK(pw::Status::Unknown()); }
+TEST_F(AssertFail, DCheckEnum) { PW_DCHECK_OK(PW_STATUS_UNKNOWN); }
 #else  // PW_ASSERT_ENABLE_DEBUG
 
 // In release mode, all the asserts should pass.
-TEST_F(AssertPass, DCheckConstant) { PW_DCHECK_OK(pw::Status::OK); }
-TEST_F(AssertPass, DCheckDynamic) { PW_DCHECK_OK(MakeStatus(pw::Status::OK)); }
-TEST_F(AssertPass, DCheckConstant) { PW_DCHECK_OK(pw::Status::UNKNOWN); }
-TEST_F(AssertPass, DCheckDynamic) {
-  PW_DCHECK_OK(MakeStatus(pw::Status::UNKNOWN));
-}
+TEST_F(AssertPass, DCheckFunction_Ok) { PW_DCHECK_OK(pw::Status::Ok()); }
+TEST_F(AssertPass, DCheckEnum_Ok) { PW_DCHECK_OK(PW_STATUS_OK); }
+TEST_F(AssertPass, DCheckFunction_Err) { PW_DCHECK_OK(pw::Status::Unknown()); }
+TEST_F(AssertPass, DCheckEnum_Err) { PW_DCHECK_OK(PW_STATUS_UNKNOWN); }
 #endif  // PW_ASSERT_ENABLE_DEBUG
 
 // TODO: Figure out how to run some of these tests is C.
diff --git a/pw_blob_store/blob_store.cc b/pw_blob_store/blob_store.cc
index 96a40f8..5e1f543 100644
--- a/pw_blob_store/blob_store.cc
+++ b/pw_blob_store/blob_store.cc
@@ -23,7 +23,7 @@
 
 Status BlobStore::Init() {
   if (initialized_) {
-    return Status::OK;
+    return Status::Ok();
   }
 
   PW_LOG_INFO("Init BlobStore");
@@ -46,7 +46,7 @@
 
     PW_LOG_DEBUG("BlobStore init - Have valid blob of %u bytes",
                  static_cast<unsigned>(write_address_));
-    return Status::OK;
+    return Status::Ok();
   }
 
   // No saved blob, check for flash being erased.
@@ -61,36 +61,36 @@
   } else {
     PW_LOG_DEBUG("BlobStore init - not erased");
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status BlobStore::LoadMetadata() {
   if (!kvs_.Get(MetadataKey(), &metadata_).ok()) {
     // If no metadata was read, make sure the metadata is reset.
     metadata_.reset();
-    return Status::NOT_FOUND;
+    return Status::NotFound();
   }
 
   if (!ValidateChecksum().ok()) {
     PW_LOG_ERROR("BlobStore init - Invalidating blob with invalid checksum");
     Invalidate();
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 size_t BlobStore::MaxDataSizeBytes() const { return partition_.size_bytes(); }
 
 Status BlobStore::OpenWrite() {
   if (!initialized_) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
 
   // Writer can only be opened if there are no other writer or readers already
   // open.
   if (writer_open_ || readers_open_ != 0) {
-    return Status::UNAVAILABLE;
+    return Status::Unavailable();
   }
 
   PW_LOG_DEBUG("Blob writer open");
@@ -99,28 +99,28 @@
 
   Invalidate();
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status BlobStore::OpenRead() {
   if (!initialized_) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
 
   // Reader can only be opened if there is no writer open.
   if (writer_open_) {
-    return Status::UNAVAILABLE;
+    return Status::Unavailable();
   }
 
   if (!ValidToRead()) {
     PW_LOG_ERROR("Blob reader unable open without valid data");
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
 
   PW_LOG_DEBUG("Blob reader open");
 
   readers_open_++;
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status BlobStore::CloseWrite() {
@@ -128,11 +128,11 @@
     // If not valid to write, there was data loss and the close will result in a
     // not valid blob. Don't need to flush any write buffered bytes.
     if (!ValidToWrite()) {
-      return Status::DATA_LOSS;
+      return Status::DataLoss();
     }
 
     if (write_address_ == 0) {
-      return Status::OK;
+      return Status::Ok();
     }
 
     PW_LOG_DEBUG(
@@ -164,14 +164,14 @@
 
     if (!ValidateChecksum().ok()) {
       Invalidate();
-      return Status::DATA_LOSS;
+      return Status::DataLoss();
     }
 
     if (!kvs_.Put(MetadataKey(), metadata_).ok()) {
-      return Status::DATA_LOSS;
+      return Status::DataLoss();
     }
 
-    return Status::OK;
+    return Status::Ok();
   };
 
   const Status status = do_close_write();
@@ -179,36 +179,36 @@
 
   if (!status.ok()) {
     valid_data_ = false;
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status BlobStore::CloseRead() {
   PW_CHECK_UINT_GT(readers_open_, 0);
   readers_open_--;
   PW_LOG_DEBUG("Blob reader close");
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status BlobStore::Write(ConstByteSpan data) {
   if (!ValidToWrite()) {
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
   if (data.size_bytes() == 0) {
-    return Status::OK;
+    return Status::Ok();
   }
   if (WriteBytesRemaining() == 0) {
-    return Status::OUT_OF_RANGE;
+    return Status::OutOfRange();
   }
   if (WriteBytesRemaining() < data.size_bytes()) {
-    return Status::RESOURCE_EXHAUSTED;
+    return Status::ResourceExhausted();
   }
 
   Status status = EraseIfNeeded();
   // TODO: switch to TRY once available.
   if (!status.ok()) {
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
   // Write in (up to) 3 steps:
@@ -242,14 +242,14 @@
       // If there was not enough bytes to finish filling the write buffer, there
       // should not be any bytes left.
       PW_DCHECK(data.size_bytes() == 0);
-      return Status::OK;
+      return Status::Ok();
     }
 
     // The write buffer is full, flush to flash.
     Status status = CommitToFlash(write_buffer_);
     // TODO: switch to TRY once available.
     if (!status.ok()) {
-      return Status::DATA_LOSS;
+      return Status::DataLoss();
     }
 
     PW_DCHECK(WriteBufferEmpty());
@@ -267,7 +267,7 @@
     Status status = CommitToFlash(data.first(flash_write_size_bytes_));
     // TODO: switch to TRY once available.
     if (!status.ok()) {
-      return Status::DATA_LOSS;
+      return Status::DataLoss();
     }
 
     data = data.subspan(flash_write_size_bytes_);
@@ -283,18 +283,18 @@
     write_address_ += data.size_bytes();
   }
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status BlobStore::AddToWriteBuffer(ConstByteSpan data) {
   if (!ValidToWrite()) {
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
   if (WriteBytesRemaining() == 0) {
-    return Status::OUT_OF_RANGE;
+    return Status::OutOfRange();
   }
   if (WriteBufferBytesFree() < data.size_bytes()) {
-    return Status::RESOURCE_EXHAUSTED;
+    return Status::ResourceExhausted();
   }
 
   size_t bytes_in_buffer = WriteBufferBytesUsed();
@@ -303,15 +303,15 @@
       write_buffer_.data() + bytes_in_buffer, data.data(), data.size_bytes());
   write_address_ += data.size_bytes();
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status BlobStore::Flush() {
   if (!ValidToWrite()) {
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
   if (WriteBufferBytesUsed() == 0) {
-    return Status::OK;
+    return Status::Ok();
   }
   // Don't need to check available space, AddToWriteBuffer() will not enqueue
   // more than can be written to flash.
@@ -319,7 +319,7 @@
   Status status = EraseIfNeeded();
   // TODO: switch to TRY once available.
   if (!status.ok()) {
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
   ByteSpan data = std::span(write_buffer_.data(), WriteBufferBytesUsed());
@@ -327,7 +327,7 @@
     Status status = CommitToFlash(data.first(flash_write_size_bytes_));
     // TODO: switch to TRY once available.
     if (!status.ok()) {
-      return Status::DATA_LOSS;
+      return Status::DataLoss();
     }
 
     data = data.subspan(flash_write_size_bytes_);
@@ -345,7 +345,7 @@
     PW_DCHECK_UINT_EQ(data.size_bytes(), 0);
   }
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status BlobStore::FlushFinalPartialChunk() {
@@ -406,15 +406,15 @@
     // Always just erase. Erase is smart enough to only erase if needed.
     return Erase();
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 StatusWithSize BlobStore::Read(size_t offset, ByteSpan dest) const {
   if (!ValidToRead()) {
-    return StatusWithSize::FAILED_PRECONDITION;
+    return StatusWithSize::FailedPrecondition();
   }
   if (offset >= ReadableDataBytes()) {
-    return StatusWithSize::OUT_OF_RANGE;
+    return StatusWithSize::OutOfRange();
   }
 
   size_t available_bytes = ReadableDataBytes() - offset;
@@ -425,12 +425,12 @@
 
 Result<ConstByteSpan> BlobStore::GetMemoryMappedBlob() const {
   if (!ValidToRead()) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
 
   std::byte* mcu_address = partition_.PartitionAddressToMcuAddress(0);
   if (mcu_address == nullptr) {
-    return Status::UNIMPLEMENTED;
+    return Status::Unimplemented();
   }
   return ConstByteSpan(mcu_address, ReadableDataBytes());
 }
@@ -451,7 +451,7 @@
     // Erased blobs should be valid as soon as the flash is erased. Even though
     // there are 0 bytes written, they are valid.
     PW_DCHECK(valid_data_);
-    return Status::OK;
+    return Status::Ok();
   }
 
   Invalidate();
@@ -480,25 +480,25 @@
 
   Status status = kvs_.Delete(MetadataKey());
 
-  return (status == Status::OK || status == Status::NOT_FOUND)
-             ? Status::OK
-             : Status::INTERNAL;
+  return (status == Status::Ok() || status == Status::NotFound())
+             ? Status::Ok()
+             : Status::Internal();
 }
 
 Status BlobStore::ValidateChecksum() {
   if (metadata_.data_size_bytes == 0) {
     PW_LOG_INFO("Blob unable to validate checksum of an empty blob");
-    return Status::UNAVAILABLE;
+    return Status::Unavailable();
   }
 
   if (checksum_algo_ == nullptr) {
     if (metadata_.checksum != 0) {
       PW_LOG_ERROR(
           "Blob invalid to have a checkum value with no checksum algo");
-      return Status::DATA_LOSS;
+      return Status::DataLoss();
     }
 
-    return Status::OK;
+    return Status::Ok();
   }
 
   PW_LOG_DEBUG("Validate checksum of 0x%08x in flash for blob of %u bytes",
@@ -515,7 +515,7 @@
 
 Status BlobStore::CalculateChecksumFromFlash(size_t bytes_to_check) {
   if (checksum_algo_ == nullptr) {
-    return Status::OK;
+    return Status::Ok();
   }
 
   checksum_algo_->Reset();
@@ -536,7 +536,7 @@
   // Safe to ignore the return from Finish, checksum_algo_ keeps the state
   // information that it needs.
   checksum_algo_->Finish();
-  return Status::OK;
+  return Status::Ok();
 }
 
 }  // namespace pw::blob_store
diff --git a/pw_blob_store/blob_store_chunk_write_test.cc b/pw_blob_store/blob_store_chunk_write_test.cc
index ccbd26d..cf7219d 100644
--- a/pw_blob_store/blob_store_chunk_write_test.cc
+++ b/pw_blob_store/blob_store_chunk_write_test.cc
@@ -60,11 +60,11 @@
 
     BlobStoreBuffer<kBufferSize> blob(
         name, partition_, &checksum, kvs::TestKvs());
-    EXPECT_EQ(Status::OK, blob.Init());
+    EXPECT_EQ(Status::Ok(), blob.Init());
 
     BlobStore::BlobWriter writer(blob);
-    EXPECT_EQ(Status::OK, writer.Open());
-    EXPECT_EQ(Status::OK, writer.Erase());
+    EXPECT_EQ(Status::Ok(), writer.Open());
+    EXPECT_EQ(Status::Ok(), writer.Erase());
 
     ByteSpan source = source_buffer_;
     while (source.size_bytes() > 0) {
@@ -74,20 +74,20 @@
                    static_cast<unsigned>(write_size),
                    static_cast<unsigned>(source.size_bytes()));
 
-      ASSERT_EQ(Status::OK, writer.Write(source.first(write_size)));
+      ASSERT_EQ(Status::Ok(), writer.Write(source.first(write_size)));
 
       source = source.subspan(write_size);
     }
 
-    EXPECT_EQ(Status::OK, writer.Close());
+    EXPECT_EQ(Status::Ok(), writer.Close());
 
     // Use reader to check for valid data.
     BlobStore::BlobReader reader(blob);
-    ASSERT_EQ(Status::OK, reader.Open());
+    ASSERT_EQ(Status::Ok(), reader.Open());
     Result<ConstByteSpan> result = reader.GetMemoryMappedBlob();
     ASSERT_TRUE(result.ok());
     VerifyFlash(result.value());
-    EXPECT_EQ(Status::OK, reader.Close());
+    EXPECT_EQ(Status::Ok(), reader.Close());
   }
 
   void VerifyFlash(ConstByteSpan verify_bytes) {
diff --git a/pw_blob_store/blob_store_deferred_write_test.cc b/pw_blob_store/blob_store_deferred_write_test.cc
index 4f3d581..71996e1 100644
--- a/pw_blob_store/blob_store_deferred_write_test.cc
+++ b/pw_blob_store/blob_store_deferred_write_test.cc
@@ -63,10 +63,10 @@
 
     BlobStoreBuffer<kBufferSize> blob(
         name, partition_, &checksum, kvs::TestKvs(), kWriteSize);
-    EXPECT_EQ(Status::OK, blob.Init());
+    EXPECT_EQ(Status::Ok(), blob.Init());
 
     BlobStore::DeferredWriter writer(blob);
-    EXPECT_EQ(Status::OK, writer.Open());
+    EXPECT_EQ(Status::Ok(), writer.Open());
 
     ByteSpan source = buffer_;
     while (source.size_bytes() > 0) {
@@ -76,7 +76,7 @@
                    static_cast<unsigned>(write_size),
                    static_cast<unsigned>(source.size_bytes()));
 
-      ASSERT_EQ(Status::OK, writer.Write(source.first(write_size)));
+      ASSERT_EQ(Status::Ok(), writer.Write(source.first(write_size)));
       // TODO: Add check that the write did not go to flash yet.
 
       source = source.subspan(write_size);
@@ -84,19 +84,19 @@
 
       if (bytes_since_flush >= flush_interval) {
         bytes_since_flush = 0;
-        ASSERT_EQ(Status::OK, writer.Flush());
+        ASSERT_EQ(Status::Ok(), writer.Flush());
       }
     }
 
-    EXPECT_EQ(Status::OK, writer.Close());
+    EXPECT_EQ(Status::Ok(), writer.Close());
 
     // Use reader to check for valid data.
     BlobStore::BlobReader reader(blob);
-    ASSERT_EQ(Status::OK, reader.Open());
+    ASSERT_EQ(Status::Ok(), reader.Open());
     Result<ConstByteSpan> result = reader.GetMemoryMappedBlob();
     ASSERT_TRUE(result.ok());
     VerifyFlash(result.value());
-    EXPECT_EQ(Status::OK, reader.Close());
+    EXPECT_EQ(Status::Ok(), reader.Close());
   }
 
   void VerifyFlash(ConstByteSpan verify_bytes) {
diff --git a/pw_blob_store/blob_store_test.cc b/pw_blob_store/blob_store_test.cc
index d21bd9d..880c516 100644
--- a/pw_blob_store/blob_store_test.cc
+++ b/pw_blob_store/blob_store_test.cc
@@ -61,21 +61,21 @@
 
     BlobStoreBuffer<kBufferSize> blob(
         name, partition_, &checksum, kvs::TestKvs());
-    EXPECT_EQ(Status::OK, blob.Init());
+    EXPECT_EQ(Status::Ok(), blob.Init());
 
     BlobStore::BlobWriter writer(blob);
-    EXPECT_EQ(Status::OK, writer.Open());
-    EXPECT_EQ(Status::OK, writer.Erase());
-    ASSERT_EQ(Status::OK, writer.Write(source_buffer_));
-    EXPECT_EQ(Status::OK, writer.Close());
+    EXPECT_EQ(Status::Ok(), writer.Open());
+    EXPECT_EQ(Status::Ok(), writer.Erase());
+    ASSERT_EQ(Status::Ok(), writer.Write(source_buffer_));
+    EXPECT_EQ(Status::Ok(), writer.Close());
 
     // Use reader to check for valid data.
     BlobStore::BlobReader reader(blob);
-    ASSERT_EQ(Status::OK, reader.Open());
+    ASSERT_EQ(Status::Ok(), reader.Open());
     Result<ConstByteSpan> result = reader.GetMemoryMappedBlob();
     ASSERT_TRUE(result.ok());
     VerifyFlash(result.value());
-    EXPECT_EQ(Status::OK, reader.Close());
+    EXPECT_EQ(Status::Ok(), reader.Close());
   }
 
   // Open a new blob instance and read the blob using the given read chunk size.
@@ -86,18 +86,18 @@
 
     char name[16] = "TestBlobBlock";
     BlobStoreBuffer<16> blob(name, partition_, &checksum, kvs::TestKvs());
-    EXPECT_EQ(Status::OK, blob.Init());
+    EXPECT_EQ(Status::Ok(), blob.Init());
 
     // Use reader to check for valid data.
     BlobStore::BlobReader reader1(blob);
-    ASSERT_EQ(Status::OK, reader1.Open());
+    ASSERT_EQ(Status::Ok(), reader1.Open());
     Result<ConstByteSpan> result = reader1.GetMemoryMappedBlob();
     ASSERT_TRUE(result.ok());
     VerifyFlash(result.value());
-    EXPECT_EQ(Status::OK, reader1.Close());
+    EXPECT_EQ(Status::Ok(), reader1.Close());
 
     BlobStore::BlobReader reader(blob);
-    ASSERT_EQ(Status::OK, reader.Open());
+    ASSERT_EQ(Status::Ok(), reader.Open());
 
     std::array<std::byte, kBlobDataSize> read_buffer_;
 
@@ -111,10 +111,10 @@
 
       ASSERT_EQ(read_span.size_bytes(), reader.ConservativeReadLimit());
       auto result = reader.Read(read_span.first(read_size));
-      ASSERT_EQ(result.status(), Status::OK);
+      ASSERT_EQ(result.status(), Status::Ok());
       read_span = read_span.subspan(read_size);
     }
-    EXPECT_EQ(Status::OK, reader.Close());
+    EXPECT_EQ(Status::Ok(), reader.Close());
 
     VerifyFlash(read_buffer_);
   }
@@ -143,7 +143,7 @@
 
 TEST_F(BlobStoreTest, Init_Ok) {
   BlobStoreBuffer<256> blob("Blob_OK", partition_, nullptr, kvs::TestKvs());
-  EXPECT_EQ(Status::OK, blob.Init());
+  EXPECT_EQ(Status::Ok(), blob.Init());
 }
 
 TEST_F(BlobStoreTest, Discard) {
@@ -153,24 +153,24 @@
   kvs::ChecksumCrc16 checksum;
   BlobStoreBuffer<256> blob(
       "TestBlobBlock", partition_, &checksum, kvs::TestKvs());
-  EXPECT_EQ(Status::OK, blob.Init());
+  EXPECT_EQ(Status::Ok(), blob.Init());
 
   BlobStore::BlobWriter writer(blob);
-  EXPECT_EQ(Status::OK, writer.Open());
-  EXPECT_EQ(Status::OK, writer.Discard());
-  EXPECT_EQ(Status::OK, writer.Close());
+  EXPECT_EQ(Status::Ok(), writer.Open());
+  EXPECT_EQ(Status::Ok(), writer.Discard());
+  EXPECT_EQ(Status::Ok(), writer.Close());
 }
 
 TEST_F(BlobStoreTest, MultipleErase) {
   BlobStoreBuffer<256> blob("Blob_OK", partition_, nullptr, kvs::TestKvs());
-  EXPECT_EQ(Status::OK, blob.Init());
+  EXPECT_EQ(Status::Ok(), blob.Init());
 
   BlobStore::BlobWriter writer(blob);
-  EXPECT_EQ(Status::OK, writer.Open());
+  EXPECT_EQ(Status::Ok(), writer.Open());
 
-  EXPECT_EQ(Status::OK, writer.Erase());
-  EXPECT_EQ(Status::OK, writer.Erase());
-  EXPECT_EQ(Status::OK, writer.Erase());
+  EXPECT_EQ(Status::Ok(), writer.Erase());
+  EXPECT_EQ(Status::Ok(), writer.Erase());
+  EXPECT_EQ(Status::Ok(), writer.Erase());
 }
 
 TEST_F(BlobStoreTest, OffsetRead) {
@@ -184,17 +184,17 @@
 
   char name[16] = "TestBlobBlock";
   BlobStoreBuffer<16> blob(name, partition_, &checksum, kvs::TestKvs());
-  EXPECT_EQ(Status::OK, blob.Init());
+  EXPECT_EQ(Status::Ok(), blob.Init());
   BlobStore::BlobReader reader(blob);
-  ASSERT_EQ(Status::OK, reader.Open(kOffset));
+  ASSERT_EQ(Status::Ok(), reader.Open(kOffset));
 
   std::array<std::byte, kBlobDataSize - kOffset> read_buffer_;
   ByteSpan read_span = read_buffer_;
   ASSERT_EQ(read_span.size_bytes(), reader.ConservativeReadLimit());
 
   auto result = reader.Read(read_span);
-  ASSERT_EQ(result.status(), Status::OK);
-  EXPECT_EQ(Status::OK, reader.Close());
+  ASSERT_EQ(result.status(), Status::Ok());
+  EXPECT_EQ(Status::Ok(), reader.Close());
   VerifyFlash(read_buffer_, kOffset);
 }
 
@@ -208,9 +208,9 @@
 
   char name[16] = "TestBlobBlock";
   BlobStoreBuffer<16> blob(name, partition_, &checksum, kvs::TestKvs());
-  EXPECT_EQ(Status::OK, blob.Init());
+  EXPECT_EQ(Status::Ok(), blob.Init());
   BlobStore::BlobReader reader(blob);
-  ASSERT_EQ(Status::INVALID_ARGUMENT, reader.Open(kOffset));
+  ASSERT_EQ(Status::InvalidArgument(), reader.Open(kOffset));
 }
 
 TEST_F(BlobStoreTest, ChunkRead1) {
diff --git a/pw_blob_store/public/pw_blob_store/blob_store.h b/pw_blob_store/public/pw_blob_store/blob_store.h
index 1fd5263..e8b1db0 100644
--- a/pw_blob_store/public/pw_blob_store/blob_store.h
+++ b/pw_blob_store/public/pw_blob_store/blob_store.h
@@ -200,10 +200,10 @@
     Status Open(size_t offset = 0) {
       PW_DCHECK(!open_);
       if (!store_.ValidToRead()) {
-        return Status::FAILED_PRECONDITION;
+        return Status::FailedPrecondition();
       }
       if (offset >= store_.ReadableDataBytes()) {
-        return Status::INVALID_ARGUMENT;
+        return Status::InvalidArgument();
       }
 
       offset_ = offset;
diff --git a/pw_bytes/byte_builder.cc b/pw_bytes/byte_builder.cc
index bcfc9de..ba01c0f 100644
--- a/pw_bytes/byte_builder.cc
+++ b/pw_bytes/byte_builder.cc
@@ -34,21 +34,21 @@
   }
 
   if (bytes_to_append > max_size() - size()) {
-    status_ = Status::RESOURCE_EXHAUSTED;
+    status_ = Status::ResourceExhausted();
     return 0;
   }
 
   size_ += bytes_to_append;
-  status_ = Status::OK;
+  status_ = Status::Ok();
   return bytes_to_append;
 }
 
 void ByteBuilder::resize(size_t new_size) {
   if (new_size <= size_) {
     size_ = new_size;
-    status_ = Status::OK;
+    status_ = Status::Ok();
   } else {
-    status_ = Status::OUT_OF_RANGE;
+    status_ = Status::OutOfRange();
   }
 }
 
diff --git a/pw_bytes/byte_builder_test.cc b/pw_bytes/byte_builder_test.cc
index 2f81de7..d1d1e7b 100644
--- a/pw_bytes/byte_builder_test.cc
+++ b/pw_bytes/byte_builder_test.cc
@@ -99,7 +99,7 @@
   constexpr auto kBytesTestLiteral = MakeBytes(0x04, 0x05, 0x06, 0x07);
 
   EXPECT_FALSE(bb.append(kBytesTestLiteral.data(), 4).ok());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), bb.status());
   EXPECT_EQ(0u, bb.size());
 }
 
@@ -129,7 +129,7 @@
 TEST(ByteBuilder, Append_Bytes_Exhausted) {
   ByteBuffer<8> bb;
 
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.append(9, byte{0x04}).status());
+  EXPECT_EQ(Status::ResourceExhausted(), bb.append(9, byte{0x04}).status());
   EXPECT_EQ(0u, bb.size());
 }
 
@@ -156,7 +156,7 @@
   ByteBuilder bb(buffer);
 
   bb.resize(1);
-  EXPECT_EQ(Status::OUT_OF_RANGE, bb.append(9, byte{0x04}).status());
+  EXPECT_EQ(Status::OutOfRange(), bb.append(9, byte{0x04}).status());
 }
 
 TEST(ByteBuilder, Resize_Smaller) {
@@ -192,12 +192,12 @@
   EXPECT_EQ(3u, bb.size());
   bb.resize(5);
   EXPECT_EQ(3u, bb.size());
-  EXPECT_EQ(bb.status(), Status::OUT_OF_RANGE);
+  EXPECT_EQ(bb.status(), Status::OutOfRange());
 }
 
 TEST(ByteBuilder, Status_StartsOk) {
   ByteBuffer<16> bb;
-  EXPECT_EQ(Status::OK, bb.status());
+  EXPECT_EQ(Status::Ok(), bb.status());
 }
 
 TEST(ByteBuilder, Status_StatusUpdate) {
@@ -205,13 +205,13 @@
   ByteBuffer<2> bb;
 
   EXPECT_FALSE(bb.append(buffer).ok());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), bb.status());
 
   bb.resize(4);
-  EXPECT_EQ(Status::OUT_OF_RANGE, bb.status());
+  EXPECT_EQ(Status::OutOfRange(), bb.status());
 
   EXPECT_FALSE(bb.append(buffer.data(), 0).ok());
-  EXPECT_EQ(Status::OUT_OF_RANGE, bb.status());
+  EXPECT_EQ(Status::OutOfRange(), bb.status());
 }
 
 TEST(ByteBuilder, Status_ClearStatus_SetsStatusToOk) {
@@ -219,16 +219,16 @@
   ByteBuffer<2> bb;
 
   EXPECT_FALSE(bb.append(buffer).ok());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), bb.status());
 
   bb.clear_status();
-  EXPECT_EQ(Status::OK, bb.status());
+  EXPECT_EQ(Status::Ok(), bb.status());
 }
 
 TEST(ByteBuilder, PushBack) {
   ByteBuffer<12> bb;
   bb.push_back(byte{0x01});
-  EXPECT_EQ(Status::OK, bb.status());
+  EXPECT_EQ(Status::Ok(), bb.status());
   EXPECT_EQ(1u, bb.size());
   EXPECT_EQ(byte{0x01}, bb.data()[0]);
 }
@@ -236,7 +236,7 @@
 TEST(ByteBuilder, PushBack_Full) {
   ByteBuffer<1> bb;
   bb.push_back(byte{0x01});
-  EXPECT_EQ(Status::OK, bb.status());
+  EXPECT_EQ(Status::Ok(), bb.status());
   EXPECT_EQ(1u, bb.size());
 }
 
@@ -245,7 +245,7 @@
   bb.push_back(byte{0x01});
   bb.push_back(byte{0x01});
 
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), bb.status());
   EXPECT_EQ(1u, bb.size());
 }
 
@@ -256,7 +256,7 @@
   bb.append(buffer.data(), 3);
 
   bb.pop_back();
-  EXPECT_EQ(Status::OK, bb.status());
+  EXPECT_EQ(Status::Ok(), bb.status());
   EXPECT_EQ(2u, bb.size());
   EXPECT_EQ(byte{0x01}, bb.data()[0]);
   EXPECT_EQ(byte{0x02}, bb.data()[1]);
@@ -270,7 +270,7 @@
   bb.pop_back();
   bb.pop_back();
   bb.pop_back();
-  EXPECT_EQ(Status::OK, bb.status());
+  EXPECT_EQ(Status::Ok(), bb.status());
   EXPECT_EQ(0u, bb.size());
   EXPECT_TRUE(bb.empty());
 }
@@ -306,13 +306,13 @@
   two.push_back(byte{0x01});
   two.push_back(byte{0x01});
   two.push_back(byte{0x01});
-  ASSERT_EQ(Status::RESOURCE_EXHAUSTED, two.status());
+  ASSERT_EQ(Status::ResourceExhausted(), two.status());
 
   one = two;
   EXPECT_EQ(byte{0x01}, two.data()[7]);
   EXPECT_EQ(byte{0x01}, two.data()[8]);
   EXPECT_EQ(byte{0x01}, two.data()[9]);
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, one.status());
+  EXPECT_EQ(Status::ResourceExhausted(), one.status());
 }
 
 TEST(ByteBuffer, CopyConstructFromSameSize) {
@@ -338,7 +338,7 @@
 
   EXPECT_EQ(byte{0x01}, two.data()[0]);
   EXPECT_EQ(byte{0x02}, two.data()[1]);
-  EXPECT_EQ(Status::OK, two.status());
+  EXPECT_EQ(Status::Ok(), two.status());
 }
 
 TEST(ByteBuilder, ResizeError_NoDataAddedAfter) {
@@ -350,11 +350,11 @@
   EXPECT_EQ(3u, bb.size());
   bb.resize(5);
   EXPECT_EQ(3u, bb.size());
-  EXPECT_EQ(bb.status(), Status::OUT_OF_RANGE);
+  EXPECT_EQ(bb.status(), Status::OutOfRange());
 
   bb.PutInt8(0xFE);
   EXPECT_EQ(3u, bb.size());
-  EXPECT_EQ(bb.status(), Status::OUT_OF_RANGE);
+  EXPECT_EQ(bb.status(), Status::OutOfRange());
 }
 
 TEST(ByteBuilder, AddingNoBytesToZeroSizedByteBuffer) {
@@ -372,7 +372,7 @@
 
   EXPECT_EQ(byte{0xFE}, bb.data()[0]);
   EXPECT_EQ(byte{0x02}, bb.data()[1]);
-  EXPECT_EQ(Status::OK, bb.status());
+  EXPECT_EQ(Status::Ok(), bb.status());
 }
 
 TEST(ByteBuffer, Putting8ByteInts_Exhausted) {
@@ -383,7 +383,7 @@
 
   EXPECT_EQ(byte{0xFE}, bb.data()[0]);
   EXPECT_EQ(byte{0x02}, bb.data()[1]);
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), bb.status());
 }
 
 TEST(ByteBuffer, Putting16ByteInts_Full_kLittleEndian) {
@@ -396,7 +396,7 @@
   EXPECT_EQ(byte{0x08}, bb.data()[2]);
   EXPECT_EQ(byte{0x00}, bb.data()[3]);
 
-  EXPECT_EQ(Status::OK, bb.status());
+  EXPECT_EQ(Status::Ok(), bb.status());
 }
 
 TEST(ByteBuffer, Putting16ByteInts_Exhausted_kBigEndian) {
@@ -411,7 +411,7 @@
 
   bb.PutInt16(0xFAFA, std::endian::big);
   EXPECT_EQ(4u, bb.size());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), bb.status());
 }
 
 TEST(ByteBuffer, Putting32ByteInts_Full_kLittleEndian) {
@@ -428,7 +428,7 @@
   EXPECT_EQ(byte{0x00}, bb.data()[6]);
   EXPECT_EQ(byte{0x00}, bb.data()[7]);
 
-  EXPECT_EQ(Status::OK, bb.status());
+  EXPECT_EQ(Status::Ok(), bb.status());
 }
 
 TEST(ByteBuffer, Putting32ByteInts_Exhausted_kBigEndian) {
@@ -447,7 +447,7 @@
 
   bb.PutInt32(-114743374, std::endian::big);
   EXPECT_EQ(8u, bb.size());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), bb.status());
 }
 
 TEST(ByteBuffer, Putting64ByteInts_Full_kLittleEndian) {
@@ -472,7 +472,7 @@
   EXPECT_EQ(byte{0xFF}, bb.data()[14]);
   EXPECT_EQ(byte{0xFF}, bb.data()[15]);
 
-  EXPECT_EQ(Status::OK, bb.status());
+  EXPECT_EQ(Status::Ok(), bb.status());
 }
 
 TEST(ByteBuffer, Putting64ByteInts_Exhausted_kBigEndian) {
@@ -499,7 +499,7 @@
 
   bb.PutInt64(-6099875637501324530, std::endian::big);
   EXPECT_EQ(16u, bb.size());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), bb.status());
 }
 
 TEST(ByteBuffer, PuttingInts_MixedTypes_MixedEndian) {
@@ -527,7 +527,7 @@
   EXPECT_EQ(byte{0x17}, bb.data()[14]);
   EXPECT_EQ(byte{0xFB}, bb.data()[15]);
 
-  EXPECT_EQ(Status::OK, bb.status());
+  EXPECT_EQ(Status::Ok(), bb.status());
 }
 
 TEST(ByteBuffer, Iterator) {
diff --git a/pw_bytes/public/pw_bytes/byte_builder.h b/pw_bytes/public/pw_bytes/byte_builder.h
index 70c0876..f046cb0 100644
--- a/pw_bytes/public/pw_bytes/byte_builder.h
+++ b/pw_bytes/public/pw_bytes/byte_builder.h
@@ -228,7 +228,7 @@
     return StatusWithSize(status_, size_);
   }
 
-  // True if status() is Status::OK.
+  // True if status() is Status::Ok().
   bool ok() const { return status_.ok(); }
 
   // True if the bytes builder is empty.
@@ -243,11 +243,11 @@
   // Clears the bytes and resets its error state.
   void clear() {
     size_ = 0;
-    status_ = Status::OK;
+    status_ = Status::Ok();
   };
 
-  // Sets the statuses to Status::OK;
-  void clear_status() { status_ = Status::OK; }
+  // Sets the statuses to Status::Ok();
+  void clear_status() { status_ = Status::Ok(); }
 
   // Appends a single byte. Sets the status to RESOURCE_EXHAUSTED if the
   // byte cannot be added because the buffer is full.
diff --git a/pw_cpu_exception_armv7m/proto_dump.cc b/pw_cpu_exception_armv7m/proto_dump.cc
index 894b2c0..086652d 100644
--- a/pw_cpu_exception_armv7m/proto_dump.cc
+++ b/pw_cpu_exception_armv7m/proto_dump.cc
@@ -55,10 +55,10 @@
   // reflected here.
   Status status = state_encoder.WriteR12(cpu_state.base.r12);
   if (!status.ok()) {
-    return status == Status::RESOURCE_EXHAUSTED ? Status::RESOURCE_EXHAUSTED
-                                                : Status::UNKNOWN;
+    return status == Status::ResourceExhausted() ? Status::ResourceExhausted()
+                                                 : Status::Unknown();
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 }  // namespace pw::cpu_exception
diff --git a/pw_hdlc_lite/decoder.cc b/pw_hdlc_lite/decoder.cc
index 37c0023..fc96824 100644
--- a/pw_hdlc_lite/decoder.cc
+++ b/pw_hdlc_lite/decoder.cc
@@ -38,13 +38,13 @@
         // Report an error if non-flag bytes were read between frames.
         if (current_frame_size_ != 0u) {
           current_frame_size_ = 0;
-          return Status::DATA_LOSS;
+          return Status::DataLoss();
         }
       } else {
         // Count bytes to track how many are discarded.
         current_frame_size_ += 1;
       }
-      return Status::UNAVAILABLE;  // Report error when starting a new frame.
+      return Status::Unavailable();  // Report error when starting a new frame.
     }
     case State::kFrame: {
       if (new_byte == kFlag) {
@@ -65,14 +65,14 @@
       } else {
         AppendByte(new_byte);
       }
-      return Status::UNAVAILABLE;
+      return Status::Unavailable();
     }
     case State::kFrameEscape: {
       // The flag character cannot be escaped; return an error.
       if (new_byte == kFlag) {
         state_ = State::kFrame;
         current_frame_size_ = 0;
-        return Status::DATA_LOSS;
+        return Status::DataLoss();
       }
 
       if (new_byte == kEscape) {
@@ -86,7 +86,7 @@
         state_ = State::kFrame;
         AppendByte(new_byte ^ kUnescapeConstant);
       }
-      return Status::UNAVAILABLE;
+      return Status::Unavailable();
     }
   }
   PW_CRASH("Bad decoder state");
@@ -104,28 +104,28 @@
 Status Decoder::CheckFrame() const {
   // Empty frames are not an error; repeated flag characters are okay.
   if (current_frame_size_ == 0u) {
-    return Status::UNAVAILABLE;
+    return Status::Unavailable();
   }
 
   if (current_frame_size_ < Frame::kMinSizeBytes) {
     PW_LOG_ERROR("Received %lu-byte frame; frame must be at least 6 bytes",
                  static_cast<unsigned long>(current_frame_size_));
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
   if (current_frame_size_ > max_size()) {
     PW_LOG_ERROR("Frame size [%lu] exceeds the maximum buffer size [%lu]",
                  static_cast<unsigned long>(current_frame_size_),
                  static_cast<unsigned long>(max_size()));
-    return Status::RESOURCE_EXHAUSTED;
+    return Status::ResourceExhausted();
   }
 
   if (!VerifyFrameCheckSequence()) {
     PW_LOG_ERROR("Frame check sequence verification failed");
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 bool Decoder::VerifyFrameCheckSequence() const {
diff --git a/pw_hdlc_lite/decoder_test.cc b/pw_hdlc_lite/decoder_test.cc
index 787fbf1..b8400e2 100644
--- a/pw_hdlc_lite/decoder_test.cc
+++ b/pw_hdlc_lite/decoder_test.cc
@@ -46,23 +46,23 @@
                   [](const Result<Frame>&) { FAIL(); });
 
   decoder.clear();
-  Status status = Status::UNKNOWN;
+  Status status = Status::Unknown();
 
   decoder.Process(
       bytes::String("~1234\xa3\xe0\xe3\x9b~"),
       [&status](const Result<Frame>& result) { status = result.status(); });
 
-  EXPECT_EQ(Status::OK, status);
+  EXPECT_EQ(Status::Ok(), status);
 }
 
 TEST(Decoder, ExactFit) {
   DecoderBuffer<8> decoder;
 
   for (byte b : bytes::String("~1234\xa3\xe0\xe3\x9b")) {
-    EXPECT_EQ(Status::UNAVAILABLE, decoder.Process(b).status());
+    EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
   }
   auto result = decoder.Process(kFlag);
-  ASSERT_EQ(Status::OK, result.status());
+  ASSERT_EQ(Status::Ok(), result.status());
   ASSERT_EQ(result.value().data().size(), 2u);
   ASSERT_EQ(result.value().data()[0], byte{'3'});
   ASSERT_EQ(result.value().data()[1], byte{'4'});
@@ -72,11 +72,11 @@
   DecoderBuffer<6> decoder;
 
   for (byte b : bytes::String("~12\xcd\x44\x53\x4f")) {
-    EXPECT_EQ(Status::UNAVAILABLE, decoder.Process(b).status());
+    EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
   }
 
   auto result = decoder.Process(kFlag);
-  ASSERT_EQ(Status::OK, result.status());
+  ASSERT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(result.value().data().size(), 0u);
 }
 
@@ -84,14 +84,14 @@
   DecoderBuffer<8> decoder;
 
   for (byte b : bytes::String("~123456789")) {
-    EXPECT_EQ(Status::UNAVAILABLE, decoder.Process(b).status());
+    EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
   }
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, decoder.Process(kFlag).status());
+  EXPECT_EQ(Status::ResourceExhausted(), decoder.Process(kFlag).status());
 
   for (byte b : bytes::String("~123456789012345678901234567890")) {
-    EXPECT_EQ(Status::UNAVAILABLE, decoder.Process(b).status());
+    EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
   }
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, decoder.Process(kFlag).status());
+  EXPECT_EQ(Status::ResourceExhausted(), decoder.Process(kFlag).status());
 }
 
 TEST(Decoder, TooLargeForBuffer_StaysWithinBufferBoundaries) {
@@ -100,28 +100,28 @@
   Decoder decoder(std::span(buffer.data(), 8));
 
   for (byte b : bytes::String("~1234567890123456789012345678901234567890")) {
-    EXPECT_EQ(Status::UNAVAILABLE, decoder.Process(b).status());
+    EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
   }
 
   for (size_t i = 8; i < buffer.size(); ++i) {
     ASSERT_EQ(byte{'?'}, buffer[i]);
   }
 
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, decoder.Process(kFlag).status());
+  EXPECT_EQ(Status::ResourceExhausted(), decoder.Process(kFlag).status());
 }
 
 TEST(Decoder, TooLargeForBuffer_DecodesNextFrame) {
   DecoderBuffer<8> decoder;
 
   for (byte b : bytes::String("~123456789012345678901234567890")) {
-    EXPECT_EQ(Status::UNAVAILABLE, decoder.Process(b).status());
+    EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
   }
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, decoder.Process(kFlag).status());
+  EXPECT_EQ(Status::ResourceExhausted(), decoder.Process(kFlag).status());
 
   for (byte b : bytes::String("1234\xa3\xe0\xe3\x9b")) {
-    EXPECT_EQ(Status::UNAVAILABLE, decoder.Process(b).status());
+    EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
   }
-  EXPECT_EQ(Status::OK, decoder.Process(kFlag).status());
+  EXPECT_EQ(Status::Ok(), decoder.Process(kFlag).status());
 }
 
 }  // namespace
diff --git a/pw_hdlc_lite/encoder.cc b/pw_hdlc_lite/encoder.cc
index dde2556..4a785ee 100644
--- a/pw_hdlc_lite/encoder.cc
+++ b/pw_hdlc_lite/encoder.cc
@@ -83,7 +83,7 @@
     }
     if (end == data.end()) {
       fcs_.Update(data);
-      return Status::OK;
+      return Status::Ok();
     }
     if (Status status = EscapeAndWrite(*end, writer_); !status.ok()) {
       return status;
diff --git a/pw_hdlc_lite/encoder_test.cc b/pw_hdlc_lite/encoder_test.cc
index 0321c86..72a66ce 100644
--- a/pw_hdlc_lite/encoder_test.cc
+++ b/pw_hdlc_lite/encoder_test.cc
@@ -50,21 +50,21 @@
   } while (0)
 
 TEST_F(WriteInfoFrame, EmptyPayload) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             WriteInformationFrame(kAddress, std::span<byte>(), writer_));
   EXPECT_ENCODER_WROTE(
       bytes::Concat(kFlag, kAddress, kControl, uint32_t{0x8D12B2C2}, kFlag));
 }
 
 TEST_F(WriteInfoFrame, OneBytePayload) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             WriteInformationFrame(kAddress, bytes::String("A"), writer_));
   EXPECT_ENCODER_WROTE(bytes::Concat(
       kFlag, kAddress, kControl, 'A', uint32_t{0xA63E2FA5}, kFlag));
 }
 
 TEST_F(WriteInfoFrame, OneBytePayload_Escape0x7d) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             WriteInformationFrame(kAddress, bytes::Array<0x7d>(), writer_));
   EXPECT_ENCODER_WROTE(bytes::Concat(kFlag,
                                      kAddress,
@@ -76,7 +76,7 @@
 }
 
 TEST_F(WriteInfoFrame, OneBytePayload_Escape0x7E) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             WriteInformationFrame(kAddress, bytes::Array<0x7e>(), writer_));
   EXPECT_ENCODER_WROTE(bytes::Concat(kFlag,
                                      kAddress,
@@ -88,14 +88,14 @@
 }
 
 TEST_F(WriteInfoFrame, AddressNeedsEscaping) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             WriteInformationFrame(0x7d, bytes::String("A"), writer_));
   EXPECT_ENCODER_WROTE(bytes::Concat(
       kFlag, kEscape, byte{0x5d}, kControl, 'A', uint32_t{0xA2B35317}, kFlag));
 }
 
 TEST_F(WriteInfoFrame, Crc32NeedsEscaping) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             WriteInformationFrame(kAddress, bytes::String("abcdefg"), writer_));
 
   // The CRC-32 is 0x38B9FC7E, so the 0x7E must be escaped.
@@ -109,9 +109,9 @@
 }
 
 TEST_F(WriteInfoFrame, MultiplePayloads) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             WriteInformationFrame(kAddress, bytes::String("ABC"), writer_));
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             WriteInformationFrame(kAddress, bytes::String("DEF"), writer_));
   EXPECT_ENCODER_WROTE(bytes::Concat(kFlag,
                                      kAddress,
@@ -128,7 +128,7 @@
 }
 
 TEST_F(WriteInfoFrame, PayloadWithNoEscapes) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             WriteInformationFrame(
                 kAddress, bytes::String("123456789012345678901234"), writer_));
 
@@ -144,7 +144,7 @@
 }
 
 TEST_F(WriteInfoFrame, PayloadWithMultipleEscapes) {
-  ASSERT_EQ(Status::OK,
+  ASSERT_EQ(Status::Ok(),
             WriteInformationFrame(
                 kAddress,
                 bytes::Array<0x7E, 0x7B, 0x61, 0x62, 0x63, 0x7D, 0x7E>(),
@@ -162,7 +162,7 @@
 TEST_F(WriteInfoFrame, WriterError) {
   constexpr auto data = bytes::Initialized<sizeof(buffer_)>(0x7e);
 
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED,
+  EXPECT_EQ(Status::ResourceExhausted(),
             WriteInformationFrame(kAddress, data, writer_));
 }
 
diff --git a/pw_hdlc_lite/public/pw_hdlc_lite/decoder.h b/pw_hdlc_lite/public/pw_hdlc_lite/decoder.h
index 1b88bb5..1e14066 100644
--- a/pw_hdlc_lite/public/pw_hdlc_lite/decoder.h
+++ b/pw_hdlc_lite/public/pw_hdlc_lite/decoder.h
@@ -97,7 +97,7 @@
   void Process(ConstByteSpan data, F&& callback, Args&&... args) {
     for (std::byte b : data) {
       auto result = Process(b);
-      if (result.status() != Status::UNAVAILABLE) {
+      if (result.status() != Status::Unavailable()) {
         std::invoke(
             std::forward<F>(callback), std::forward<Args>(args)..., result);
       }
diff --git a/pw_hdlc_lite/rpc_channel_test.cc b/pw_hdlc_lite/rpc_channel_test.cc
index c98d656..7e0d0dd 100644
--- a/pw_hdlc_lite/rpc_channel_test.cc
+++ b/pw_hdlc_lite/rpc_channel_test.cc
@@ -61,7 +61,7 @@
   constexpr auto expected = bytes::Concat(
       kFlag, kAddress, kControl, 'A', uint32_t{0xA63E2FA5}, kFlag);
 
-  EXPECT_EQ(Status::OK, output.SendAndReleaseBuffer(sizeof(test_data)));
+  EXPECT_EQ(Status::Ok(), output.SendAndReleaseBuffer(sizeof(test_data)));
 
   ASSERT_EQ(memory_writer.bytes_written(), expected.size());
   EXPECT_EQ(
@@ -88,7 +88,7 @@
                                           byte{0x7d} ^ byte{0x20},
                                           uint32_t{0x89515322},
                                           kFlag);
-  EXPECT_EQ(Status::OK, output.SendAndReleaseBuffer(test_data.size()));
+  EXPECT_EQ(Status::Ok(), output.SendAndReleaseBuffer(test_data.size()));
 
   ASSERT_EQ(memory_writer.bytes_written(), 10u);
   EXPECT_EQ(
@@ -109,7 +109,7 @@
   constexpr auto expected = bytes::Concat(
       kFlag, kAddress, kControl, 'A', uint32_t{0xA63E2FA5}, kFlag);
 
-  EXPECT_EQ(Status::OK, output.SendAndReleaseBuffer(sizeof(test_data)));
+  EXPECT_EQ(Status::Ok(), output.SendAndReleaseBuffer(sizeof(test_data)));
 
   ASSERT_EQ(memory_writer.bytes_written(), expected.size());
   EXPECT_EQ(
diff --git a/pw_hex_dump/hex_dump.cc b/pw_hex_dump/hex_dump.cc
index fef1a90..ae979df 100644
--- a/pw_hex_dump/hex_dump.cc
+++ b/pw_hex_dump/hex_dump.cc
@@ -48,11 +48,11 @@
 
 Status DumpAddr(std::span<char> dest, uintptr_t addr) {
   if (dest.data() == nullptr) {
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
   // Include null terminator.
   if (dest.size() < kHexAddrStringSize + 1) {
-    return Status::RESOURCE_EXHAUSTED;
+    return Status::ResourceExhausted();
   }
   dest[0] = '0';
   dest[1] = 'x';
@@ -123,11 +123,11 @@
 
 Status FormattedHexDumper::DumpLine() {
   if (source_data_.empty()) {
-    return Status::RESOURCE_EXHAUSTED;
+    return Status::ResourceExhausted();
   }
 
   if (!ValidateBufferSize().ok() || dest_.data() == nullptr) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
 
   if (dest_[0] == 0 && flags.show_header) {
@@ -212,22 +212,23 @@
 
 Status FormattedHexDumper::SetLineBuffer(std::span<char> dest) {
   if (dest.data() == nullptr || dest.size_bytes() == 0) {
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
   dest_ = dest;
-  return ValidateBufferSize().ok() ? Status::OK : Status::RESOURCE_EXHAUSTED;
+  return ValidateBufferSize().ok() ? Status::Ok() : Status::ResourceExhausted();
 }
 
 Status FormattedHexDumper::BeginDump(ConstByteSpan data) {
   current_offset_ = 0;
   source_data_ = data;
   if (data.data() == nullptr) {
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
   if (dest_.data() != nullptr && dest_.size_bytes() > 0) {
     dest_[0] = 0;
   }
-  return ValidateBufferSize().ok() ? Status::OK : Status::FAILED_PRECONDITION;
+  return ValidateBufferSize().ok() ? Status::Ok()
+                                   : Status::FailedPrecondition();
 }
 
 Status FormattedHexDumper::ValidateBufferSize() {
@@ -250,10 +251,10 @@
   }
 
   if (dest_.size_bytes() < required_size) {
-    return Status::RESOURCE_EXHAUSTED;
+    return Status::ResourceExhausted();
   }
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 }  // namespace pw::dump
diff --git a/pw_hex_dump/hex_dump_test.cc b/pw_hex_dump/hex_dump_test.cc
index 51ad7fa..1b10251 100644
--- a/pw_hex_dump/hex_dump_test.cc
+++ b/pw_hex_dump/hex_dump_test.cc
@@ -100,7 +100,7 @@
 TEST_F(HexDump, DumpAddr_ZeroSizeT) {
   constexpr const char* expected = EXPECTED_SIGNIFICANT_BYTES("00000000");
   size_t zero = 0;
-  EXPECT_EQ(DumpAddr(dest_, zero), Status::OK);
+  EXPECT_EQ(DumpAddr(dest_, zero), Status::Ok());
   EXPECT_STREQ(expected, dest_.data());
 }
 
@@ -156,7 +156,7 @@
   for (size_t i = 0; i < source_data.size(); i += kTestBytesPerLine) {
     EXPECT_TRUE(dumper_.DumpLine().ok());
   }
-  EXPECT_EQ(dumper_.DumpLine(), Status::RESOURCE_EXHAUSTED);
+  EXPECT_EQ(dumper_.DumpLine(), Status::ResourceExhausted());
 }
 
 // This test is provided for convenience of debugging, as it actually logs the
@@ -172,7 +172,7 @@
   while (dumper_.DumpLine().ok()) {
     PW_LOG_INFO("%s", dest_.data());
   }
-  EXPECT_EQ(dumper_.DumpLine(), Status::RESOURCE_EXHAUSTED);
+  EXPECT_EQ(dumper_.DumpLine(), Status::ResourceExhausted());
 }
 
 TEST_F(HexDump, FormattedHexDump_NoSpaces) {
@@ -351,7 +351,7 @@
   default_flags_.bytes_per_line = 13;
   dumper_ = FormattedHexDumper(dest_, default_flags_);
 
-  EXPECT_EQ(dumper_.BeginDump(source_data), Status::FAILED_PRECONDITION);
+  EXPECT_EQ(dumper_.BeginDump(source_data), Status::FailedPrecondition());
   EXPECT_FALSE(dumper_.DumpLine().ok());
   EXPECT_STREQ(expected, dest_.data());
 }
@@ -363,7 +363,7 @@
   default_flags_.group_every = 1;
   dumper_ = FormattedHexDumper(dest_, default_flags_);
 
-  EXPECT_EQ(dumper_.BeginDump(source_data), Status::FAILED_PRECONDITION);
+  EXPECT_EQ(dumper_.BeginDump(source_data), Status::FailedPrecondition());
   EXPECT_FALSE(dumper_.DumpLine().ok());
   EXPECT_STREQ(expected, dest_.data());
 }
@@ -375,7 +375,7 @@
   default_flags_.prefix_mode = FormattedHexDumper::AddressMode::kOffset;
   dumper_ = FormattedHexDumper(dest_, default_flags_);
 
-  EXPECT_EQ(dumper_.BeginDump(source_data), Status::FAILED_PRECONDITION);
+  EXPECT_EQ(dumper_.BeginDump(source_data), Status::FailedPrecondition());
   EXPECT_FALSE(dumper_.DumpLine().ok());
   EXPECT_STREQ(expected, dest_.data());
 }
@@ -383,22 +383,22 @@
 TEST(BadBuffer, ZeroSize) {
   char buffer[1] = {static_cast<char>(0xaf)};
   FormattedHexDumper dumper(std::span<char>(buffer, 0));
-  EXPECT_EQ(dumper.BeginDump(source_data), Status::FAILED_PRECONDITION);
-  EXPECT_EQ(dumper.DumpLine(), Status::FAILED_PRECONDITION);
+  EXPECT_EQ(dumper.BeginDump(source_data), Status::FailedPrecondition());
+  EXPECT_EQ(dumper.DumpLine(), Status::FailedPrecondition());
   EXPECT_EQ(buffer[0], static_cast<char>(0xaf));
 }
 
 TEST(BadBuffer, NullPtrDest) {
   FormattedHexDumper dumper;
-  EXPECT_EQ(dumper.SetLineBuffer(std::span<char>()), Status::INVALID_ARGUMENT);
-  EXPECT_EQ(dumper.BeginDump(source_data), Status::FAILED_PRECONDITION);
-  EXPECT_EQ(dumper.DumpLine(), Status::FAILED_PRECONDITION);
+  EXPECT_EQ(dumper.SetLineBuffer(std::span<char>()), Status::InvalidArgument());
+  EXPECT_EQ(dumper.BeginDump(source_data), Status::FailedPrecondition());
+  EXPECT_EQ(dumper.DumpLine(), Status::FailedPrecondition());
 }
 
 TEST(BadBuffer, NullPtrSrc) {
   char buffer[24] = {static_cast<char>(0)};
   FormattedHexDumper dumper(buffer);
-  EXPECT_EQ(dumper.BeginDump(ByteSpan(nullptr, 64)), Status::INVALID_ARGUMENT);
+  EXPECT_EQ(dumper.BeginDump(ByteSpan(nullptr, 64)), Status::InvalidArgument());
   // Don't actually dump nullptr in this test as it could cause a crash.
 }
 
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);
 }
 
diff --git a/pw_metric/metric_service_nanopb_test.cc b/pw_metric/metric_service_nanopb_test.cc
index b8b15b0..0948261 100644
--- a/pw_metric/metric_service_nanopb_test.cc
+++ b/pw_metric/metric_service_nanopb_test.cc
@@ -33,7 +33,7 @@
   MetricMethodContext context(root.metrics(), root.children());
   context.call({});
   EXPECT_TRUE(context.done());
-  EXPECT_EQ(Status::OK, context.status());
+  EXPECT_EQ(Status::Ok(), context.status());
 
   // No metrics should be in the response.
   EXPECT_EQ(0u, context.responses().size());
@@ -52,7 +52,7 @@
   MetricMethodContext context(root.metrics(), root.children());
   context.call({});
   EXPECT_TRUE(context.done());
-  EXPECT_EQ(Status::OK, context.status());
+  EXPECT_EQ(Status::Ok(), context.status());
 
   // All of the responses should have fit in one proto.
   EXPECT_EQ(1u, context.responses().size());
@@ -77,7 +77,7 @@
   MetricMethodContext context(root.metrics(), root.children());
   context.call({});
   EXPECT_TRUE(context.done());
-  EXPECT_EQ(Status::OK, context.status());
+  EXPECT_EQ(Status::Ok(), context.status());
 
   // All of the responses should fit in one proto.
   EXPECT_EQ(1u, context.responses().size());
@@ -111,7 +111,7 @@
   MetricMethodContext context(root.metrics(), root.children());
   context.call({});
   EXPECT_TRUE(context.done());
-  EXPECT_EQ(Status::OK, context.status());
+  EXPECT_EQ(Status::Ok(), context.status());
 
   // The response had to be split into two parts; check that they have the
   // appropriate sizes.
diff --git a/pw_protobuf/codegen_test.cc b/pw_protobuf/codegen_test.cc
index c9845c9..0b26657 100644
--- a/pw_protobuf/codegen_test.cc
+++ b/pw_protobuf/codegen_test.cc
@@ -167,7 +167,7 @@
   // clang-format on
 
   std::span<const std::byte> proto;
-  EXPECT_EQ(encoder.Encode(&proto), Status::OK);
+  EXPECT_EQ(encoder.Encode(&proto), Status::Ok());
   EXPECT_EQ(proto.size(), sizeof(expected_proto));
   EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
             0);
@@ -186,7 +186,7 @@
       0x08, 0x00, 0x08, 0x10, 0x08, 0x20, 0x08, 0x30};
 
   std::span<const std::byte> proto;
-  EXPECT_EQ(encoder.Encode(&proto), Status::OK);
+  EXPECT_EQ(encoder.Encode(&proto), Status::Ok());
   EXPECT_EQ(proto.size(), sizeof(expected_proto));
   EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
             0);
@@ -202,7 +202,7 @@
 
   constexpr uint8_t expected_proto[] = {0x0a, 0x04, 0x00, 0x10, 0x20, 0x30};
   std::span<const std::byte> proto;
-  EXPECT_EQ(encoder.Encode(&proto), Status::OK);
+  EXPECT_EQ(encoder.Encode(&proto), Status::Ok());
   EXPECT_EQ(proto.size(), sizeof(expected_proto));
   EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
             0);
@@ -222,7 +222,7 @@
       0x1a, 0x03, 't', 'h', 'e', 0x1a, 0x5, 'q',  'u', 'i', 'c', 'k',
       0x1a, 0x5,  'b', 'r', 'o', 'w',  'n', 0x1a, 0x3, 'f', 'o', 'x'};
   std::span<const std::byte> proto;
-  EXPECT_EQ(encoder.Encode(&proto), Status::OK);
+  EXPECT_EQ(encoder.Encode(&proto), Status::Ok());
   EXPECT_EQ(proto.size(), sizeof(expected_proto));
   EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
             0);
@@ -246,7 +246,7 @@
   // clang-format on
 
   std::span<const std::byte> proto;
-  EXPECT_EQ(encoder.Encode(&proto), Status::OK);
+  EXPECT_EQ(encoder.Encode(&proto), Status::Ok());
   EXPECT_EQ(proto.size(), sizeof(expected_proto));
   EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
             0);
@@ -270,7 +270,7 @@
       0x08, 0x03, 0x1a, 0x06, 0x0a, 0x04, 0xde, 0xad, 0xbe, 0xef};
 
   std::span<const std::byte> proto;
-  EXPECT_EQ(encoder.Encode(&proto), Status::OK);
+  EXPECT_EQ(encoder.Encode(&proto), Status::Ok());
   EXPECT_EQ(proto.size(), sizeof(expected_proto));
   EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
             0);
@@ -294,7 +294,7 @@
   }
 
   std::span<const std::byte> proto;
-  EXPECT_EQ(encoder.Encode(&proto), Status::OK);
+  EXPECT_EQ(encoder.Encode(&proto), Status::Ok());
 }
 
 TEST(Codegen, NonPigweedPackage) {
@@ -307,7 +307,7 @@
   packed.WritePacked("packed");
 
   std::span<const std::byte> proto;
-  EXPECT_EQ(encoder.Encode(&proto), Status::OK);
+  EXPECT_EQ(encoder.Encode(&proto), Status::Ok());
 }
 
 }  // namespace
diff --git a/pw_protobuf/decoder.cc b/pw_protobuf/decoder.cc
index 72127be..70880ad 100644
--- a/pw_protobuf/decoder.cc
+++ b/pw_protobuf/decoder.cc
@@ -27,24 +27,24 @@
     }
   }
   if (proto_.empty()) {
-    return Status::OUT_OF_RANGE;
+    return Status::OutOfRange();
   }
   previous_field_consumed_ = false;
-  return FieldSize() == 0 ? Status::DATA_LOSS : Status::OK;
+  return FieldSize() == 0 ? Status::DataLoss() : Status::Ok();
 }
 
 Status Decoder::SkipField() {
   if (proto_.empty()) {
-    return Status::OUT_OF_RANGE;
+    return Status::OutOfRange();
   }
 
   size_t bytes_to_skip = FieldSize();
   if (bytes_to_skip == 0) {
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
   proto_ = proto_.subspan(bytes_to_skip);
-  return proto_.empty() ? Status::OUT_OF_RANGE : Status::OK;
+  return proto_.empty() ? Status::OutOfRange() : Status::Ok();
 }
 
 uint32_t Decoder::FieldNumber() const {
@@ -60,10 +60,10 @@
     return status;
   }
   if (value > std::numeric_limits<uint32_t>::max()) {
-    return Status::OUT_OF_RANGE;
+    return Status::OutOfRange();
   }
   *out = value;
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status Decoder::ReadSint32(int32_t* out) {
@@ -73,10 +73,10 @@
     return status;
   }
   if (value > std::numeric_limits<int32_t>::max()) {
-    return Status::OUT_OF_RANGE;
+    return Status::OutOfRange();
   }
   *out = value;
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status Decoder::ReadSint64(int64_t* out) {
@@ -86,7 +86,7 @@
     return status;
   }
   *out = varint::ZigZagDecode(value);
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status Decoder::ReadBool(bool* out) {
@@ -96,7 +96,7 @@
     return status;
   }
   *out = value;
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status Decoder::ReadString(std::string_view* out) {
@@ -107,7 +107,7 @@
   }
   *out = std::string_view(reinterpret_cast<const char*>(bytes.data()),
                           bytes.size());
-  return Status::OK;
+  return Status::Ok();
 }
 
 size_t Decoder::FieldSize() const {
@@ -159,17 +159,17 @@
   uint64_t key;
   size_t bytes_read = varint::Decode(proto_, &key);
   if (bytes_read == 0) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
 
   WireType wire_type = static_cast<WireType>(key & kWireTypeMask);
   if (wire_type != expected_type) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
 
   // Advance past the key.
   proto_ = proto_.subspan(bytes_read);
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status Decoder::ReadVarint(uint64_t* out) {
@@ -179,13 +179,13 @@
 
   size_t bytes_read = varint::Decode(proto_, out);
   if (bytes_read == 0) {
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
   // Advance to the next field.
   proto_ = proto_.subspan(bytes_read);
   previous_field_consumed_ = true;
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status Decoder::ReadFixed(std::byte* out, size_t size) {
@@ -197,14 +197,14 @@
   }
 
   if (proto_.size() < size) {
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
   std::memcpy(out, proto_.data(), size);
   proto_ = proto_.subspan(size);
   previous_field_consumed_ = true;
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status Decoder::ReadDelimited(std::span<const std::byte>* out) {
@@ -216,24 +216,24 @@
   uint64_t length;
   size_t bytes_read = varint::Decode(proto_, &length);
   if (bytes_read == 0) {
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
   proto_ = proto_.subspan(bytes_read);
   if (proto_.size() < length) {
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
   *out = proto_.first(length);
   proto_ = proto_.subspan(length);
   previous_field_consumed_ = true;
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status CallbackDecoder::Decode(std::span<const std::byte> proto) {
   if (handler_ == nullptr || state_ != kReady) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
 
   state_ = kDecodeInProgress;
@@ -242,7 +242,7 @@
   // Iterate the proto, calling the handler with each field number.
   while (state_ == kDecodeInProgress) {
     if (Status status = decoder_.Next(); !status.ok()) {
-      if (status == Status::OUT_OF_RANGE) {
+      if (status == Status::OutOfRange()) {
         // Reached the end of the proto.
         break;
       }
@@ -253,7 +253,7 @@
 
     Status status = handler_->ProcessField(*this, decoder_.FieldNumber());
     if (!status.ok()) {
-      state_ = status == Status::CANCELLED ? kDecodeCancelled : kDecodeFailed;
+      state_ = status == Status::Cancelled() ? kDecodeCancelled : kDecodeFailed;
       return status;
     }
 
@@ -265,11 +265,11 @@
   }
 
   if (state_ != kDecodeInProgress) {
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
   state_ = kReady;
-  return Status::OK;
+  return Status::Ok();
 }
 
 }  // namespace pw::protobuf
diff --git a/pw_protobuf/decoder_test.cc b/pw_protobuf/decoder_test.cc
index 7dad4b2..0b4f6ff 100644
--- a/pw_protobuf/decoder_test.cc
+++ b/pw_protobuf/decoder_test.cc
@@ -50,7 +50,7 @@
     }
 
     called = true;
-    return Status::OK;
+    return Status::Ok();
   }
 
   bool called = false;
@@ -83,45 +83,45 @@
   Decoder decoder(std::as_bytes(std::span(encoded_proto)));
 
   int32_t v1 = 0;
-  EXPECT_EQ(decoder.Next(), Status::OK);
+  EXPECT_EQ(decoder.Next(), Status::Ok());
   ASSERT_EQ(decoder.FieldNumber(), 1u);
-  EXPECT_EQ(decoder.ReadInt32(&v1), Status::OK);
+  EXPECT_EQ(decoder.ReadInt32(&v1), Status::Ok());
   EXPECT_EQ(v1, 42);
 
   int32_t v2 = 0;
-  EXPECT_EQ(decoder.Next(), Status::OK);
+  EXPECT_EQ(decoder.Next(), Status::Ok());
   ASSERT_EQ(decoder.FieldNumber(), 2u);
-  EXPECT_EQ(decoder.ReadSint32(&v2), Status::OK);
+  EXPECT_EQ(decoder.ReadSint32(&v2), Status::Ok());
   EXPECT_EQ(v2, -13);
 
   bool v3 = true;
-  EXPECT_EQ(decoder.Next(), Status::OK);
+  EXPECT_EQ(decoder.Next(), Status::Ok());
   ASSERT_EQ(decoder.FieldNumber(), 3u);
-  EXPECT_EQ(decoder.ReadBool(&v3), Status::OK);
+  EXPECT_EQ(decoder.ReadBool(&v3), Status::Ok());
   EXPECT_FALSE(v3);
 
   double v4 = 0;
-  EXPECT_EQ(decoder.Next(), Status::OK);
+  EXPECT_EQ(decoder.Next(), Status::Ok());
   ASSERT_EQ(decoder.FieldNumber(), 4u);
-  EXPECT_EQ(decoder.ReadDouble(&v4), Status::OK);
+  EXPECT_EQ(decoder.ReadDouble(&v4), Status::Ok());
   EXPECT_EQ(v4, 3.14159);
 
   uint32_t v5 = 0;
-  EXPECT_EQ(decoder.Next(), Status::OK);
+  EXPECT_EQ(decoder.Next(), Status::Ok());
   ASSERT_EQ(decoder.FieldNumber(), 5u);
-  EXPECT_EQ(decoder.ReadFixed32(&v5), Status::OK);
+  EXPECT_EQ(decoder.ReadFixed32(&v5), Status::Ok());
   EXPECT_EQ(v5, 0xdeadbeef);
 
   std::string_view v6;
   char buffer[16];
-  EXPECT_EQ(decoder.Next(), Status::OK);
+  EXPECT_EQ(decoder.Next(), Status::Ok());
   ASSERT_EQ(decoder.FieldNumber(), 6u);
-  EXPECT_EQ(decoder.ReadString(&v6), Status::OK);
+  EXPECT_EQ(decoder.ReadString(&v6), Status::Ok());
   std::memcpy(buffer, v6.data(), v6.size());
   buffer[v6.size()] = '\0';
   EXPECT_STREQ(buffer, "Hello world");
 
-  EXPECT_EQ(decoder.Next(), Status::OUT_OF_RANGE);
+  EXPECT_EQ(decoder.Next(), Status::OutOfRange());
 }
 
 TEST(Decoder, Decode_SkipsUnusedFields) {
@@ -146,14 +146,14 @@
 
   // Don't process any fields except for the fourth. Next should still iterate
   // correctly despite field values not being consumed.
-  EXPECT_EQ(decoder.Next(), Status::OK);
-  EXPECT_EQ(decoder.Next(), Status::OK);
-  EXPECT_EQ(decoder.Next(), Status::OK);
-  EXPECT_EQ(decoder.Next(), Status::OK);
+  EXPECT_EQ(decoder.Next(), Status::Ok());
+  EXPECT_EQ(decoder.Next(), Status::Ok());
+  EXPECT_EQ(decoder.Next(), Status::Ok());
+  EXPECT_EQ(decoder.Next(), Status::Ok());
   ASSERT_EQ(decoder.FieldNumber(), 4u);
-  EXPECT_EQ(decoder.Next(), Status::OK);
-  EXPECT_EQ(decoder.Next(), Status::OK);
-  EXPECT_EQ(decoder.Next(), Status::OUT_OF_RANGE);
+  EXPECT_EQ(decoder.Next(), Status::Ok());
+  EXPECT_EQ(decoder.Next(), Status::Ok());
+  EXPECT_EQ(decoder.Next(), Status::OutOfRange());
 }
 
 TEST(CallbackDecoder, Decode) {
@@ -179,7 +179,7 @@
 
   decoder.set_handler(&handler);
   EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
-            Status::OK);
+            Status::Ok());
   EXPECT_TRUE(handler.called);
   EXPECT_EQ(handler.test_int32, 42);
   EXPECT_EQ(handler.test_sint32, -13);
@@ -206,7 +206,7 @@
 
   decoder.set_handler(&handler);
   EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
-            Status::OK);
+            Status::Ok());
   EXPECT_TRUE(handler.called);
   EXPECT_EQ(handler.test_int32, 44);
 }
@@ -216,7 +216,7 @@
   TestDecodeHandler handler;
 
   decoder.set_handler(&handler);
-  EXPECT_EQ(decoder.Decode(std::span<std::byte>()), Status::OK);
+  EXPECT_EQ(decoder.Decode(std::span<std::byte>()), Status::Ok());
   EXPECT_FALSE(handler.called);
   EXPECT_EQ(handler.test_int32, 0);
   EXPECT_EQ(handler.test_sint32, 0);
@@ -231,7 +231,7 @@
 
   decoder.set_handler(&handler);
   EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
-            Status::DATA_LOSS);
+            Status::DataLoss());
 }
 
 // Only processes fields numbered 1 or 3.
@@ -241,10 +241,10 @@
                       uint32_t field_number) override {
     switch (field_number) {
       case 1:
-        EXPECT_EQ(decoder.ReadInt32(&field_one), Status::OK);
+        EXPECT_EQ(decoder.ReadInt32(&field_one), Status::Ok());
         break;
       case 3:
-        EXPECT_EQ(decoder.ReadInt32(&field_three), Status::OK);
+        EXPECT_EQ(decoder.ReadInt32(&field_three), Status::Ok());
         break;
       default:
         // Do nothing.
@@ -252,7 +252,7 @@
     }
 
     called = true;
-    return Status::OK;
+    return Status::Ok();
   }
 
   bool called = false;
@@ -286,7 +286,7 @@
 
   decoder.set_handler(&handler);
   EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
-            Status::OK);
+            Status::Ok());
   EXPECT_TRUE(handler.called);
   EXPECT_EQ(handler.field_one, 42);
   EXPECT_EQ(handler.field_three, 99);
@@ -299,17 +299,17 @@
                       uint32_t field_number) override {
     switch (field_number) {
       case 1:
-        EXPECT_EQ(decoder.ReadInt32(&field_one), Status::OK);
-        return Status::CANCELLED;
+        EXPECT_EQ(decoder.ReadInt32(&field_one), Status::Ok());
+        return Status::Cancelled();
       case 3:
-        EXPECT_EQ(decoder.ReadInt32(&field_three), Status::OK);
+        EXPECT_EQ(decoder.ReadInt32(&field_three), Status::Ok());
         break;
       default:
         // Do nothing.
         break;
     }
 
-    return Status::OK;
+    return Status::Ok();
   }
 
   int32_t field_one = 0;
@@ -336,7 +336,7 @@
 
   decoder.set_handler(&handler);
   EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
-            Status::CANCELLED);
+            Status::Cancelled());
   EXPECT_EQ(handler.field_one, 42);
   EXPECT_EQ(handler.field_three, 1111);
 }
diff --git a/pw_protobuf/encoder.cc b/pw_protobuf/encoder.cc
index 96b9b7d..6a5eceb 100644
--- a/pw_protobuf/encoder.cc
+++ b/pw_protobuf/encoder.cc
@@ -32,18 +32,18 @@
 
   std::span varint_buf = buffer_.last(RemainingSize());
   if (varint_buf.empty()) {
-    encode_status_ = Status::RESOURCE_EXHAUSTED;
+    encode_status_ = Status::ResourceExhausted();
     return encode_status_;
   }
 
   size_t written = pw::varint::EncodeLittleEndianBase128(value, varint_buf);
   if (written == 0) {
-    encode_status_ = Status::RESOURCE_EXHAUSTED;
+    encode_status_ = Status::ResourceExhausted();
     return encode_status_;
   }
 
   cursor_ += written;
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status Encoder::WriteRawBytes(const std::byte* ptr, size_t size) {
@@ -52,7 +52,7 @@
   }
 
   if (size > RemainingSize()) {
-    encode_status_ = Status::RESOURCE_EXHAUSTED;
+    encode_status_ = Status::ResourceExhausted();
     return encode_status_;
   }
 
@@ -61,7 +61,7 @@
   std::memmove(cursor_, ptr, size);
 
   cursor_ += size;
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status Encoder::Push(uint32_t field_number) {
@@ -70,7 +70,7 @@
   }
 
   if (blob_count_ == blob_locations_.size() || depth_ == blob_stack_.size()) {
-    encode_status_ = Status::RESOURCE_EXHAUSTED;
+    encode_status_ = Status::ResourceExhausted();
     return encode_status_;
   }
 
@@ -85,7 +85,7 @@
   if (sizeof(SizeType) > RemainingSize()) {
     // Rollback if there isn't enough space.
     cursor_ = original_cursor;
-    encode_status_ = Status::RESOURCE_EXHAUSTED;
+    encode_status_ = Status::ResourceExhausted();
     return encode_status_;
   }
 
@@ -105,7 +105,7 @@
   blob_stack_[depth_++] = size_cursor;
 
   cursor_ += sizeof(*size_cursor);
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status Encoder::Pop() {
@@ -114,7 +114,7 @@
   }
 
   if (depth_ == 0) {
-    encode_status_ = Status::FAILED_PRECONDITION;
+    encode_status_ = Status::FailedPrecondition();
     return encode_status_;
   }
 
@@ -123,7 +123,7 @@
   SizeType child_size = *blob_stack_[--depth_];
   IncreaseParentSize(child_size + VarintSizeBytes(child_size));
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status Encoder::Encode(std::span<const std::byte>* out) {
@@ -135,7 +135,7 @@
   if (blob_count_ == 0) {
     // If there are no nested blobs, the buffer already contains a valid proto.
     *out = buffer_.first(EncodedSize());
-    return Status::OK;
+    return Status::Ok();
   }
 
   union {
@@ -180,7 +180,7 @@
   // Point the cursor to the end of the encoded proto.
   cursor_ = write_cursor;
   *out = buffer_.first(EncodedSize());
-  return Status::OK;
+  return Status::Ok();
 }
 
 }  // namespace pw::protobuf
diff --git a/pw_protobuf/encoder_test.cc b/pw_protobuf/encoder_test.cc
index 8a86057..109943d 100644
--- a/pw_protobuf/encoder_test.cc
+++ b/pw_protobuf/encoder_test.cc
@@ -85,16 +85,16 @@
   std::byte encode_buffer[32];
   NestedEncoder encoder(encode_buffer);
 
-  EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::OK);
-  EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::OK);
+  EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::Ok());
+  EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::Ok());
   EXPECT_EQ(encoder.WriteFixed64(kTestProtoCyclesField, 0xdeadbeef8badf00d),
-            Status::OK);
-  EXPECT_EQ(encoder.WriteFloat(kTestProtoRatioField, 1.618034), Status::OK);
+            Status::Ok());
+  EXPECT_EQ(encoder.WriteFloat(kTestProtoRatioField, 1.618034), Status::Ok());
   EXPECT_EQ(encoder.WriteString(kTestProtoErrorMessageField, "broken 💩"),
-            Status::OK);
+            Status::Ok());
 
   std::span<const std::byte> encoded;
-  EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
+  EXPECT_EQ(encoder.Encode(&encoded), Status::Ok());
   EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
   EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
 }
@@ -104,19 +104,19 @@
   NestedEncoder encoder(encode_buffer);
 
   // 2 bytes.
-  EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::OK);
+  EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::Ok());
   // 2 bytes.
-  EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::OK);
+  EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::Ok());
   // 9 bytes; not enough space! The encoder will start writing the field but
   // should rollback when it realizes it doesn't have enough space.
   EXPECT_EQ(encoder.WriteFixed64(kTestProtoCyclesField, 0xdeadbeef8badf00d),
-            Status::RESOURCE_EXHAUSTED);
+            Status::ResourceExhausted());
   // Any further write operations should fail.
   EXPECT_EQ(encoder.WriteFloat(kTestProtoRatioField, 1.618034),
-            Status::RESOURCE_EXHAUSTED);
+            Status::ResourceExhausted());
 
   std::span<const std::byte> encoded;
-  EXPECT_EQ(encoder.Encode(&encoded), Status::RESOURCE_EXHAUSTED);
+  EXPECT_EQ(encoder.Encode(&encoded), Status::ResourceExhausted());
   EXPECT_EQ(encoded.size(), 0u);
 }
 
@@ -124,17 +124,17 @@
   std::byte encode_buffer[12];
   NestedEncoder encoder(encode_buffer);
 
-  EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::OK);
+  EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::Ok());
   // Invalid proto field numbers.
-  EXPECT_EQ(encoder.WriteUint32(0, 1337), Status::INVALID_ARGUMENT);
+  EXPECT_EQ(encoder.WriteUint32(0, 1337), Status::InvalidArgument());
   encoder.Clear();
 
-  EXPECT_EQ(encoder.WriteString(1u << 31, "ha"), Status::INVALID_ARGUMENT);
+  EXPECT_EQ(encoder.WriteString(1u << 31, "ha"), Status::InvalidArgument());
   encoder.Clear();
 
-  EXPECT_EQ(encoder.WriteBool(19091, false), Status::INVALID_ARGUMENT);
+  EXPECT_EQ(encoder.WriteBool(19091, false), Status::InvalidArgument());
   std::span<const std::byte> encoded;
-  EXPECT_EQ(encoder.Encode(&encoded), Status::INVALID_ARGUMENT);
+  EXPECT_EQ(encoder.Encode(&encoded), Status::InvalidArgument());
   EXPECT_EQ(encoded.size(), 0u);
 }
 
@@ -144,47 +144,48 @@
 
   // TestProto test_proto;
   // test_proto.magic_number = 42;
-  EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::OK);
+  EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::Ok());
 
   {
     // NestedProto& nested_proto = test_proto.nested;
-    EXPECT_EQ(encoder.Push(kTestProtoNestedField), Status::OK);
+    EXPECT_EQ(encoder.Push(kTestProtoNestedField), Status::Ok());
     // nested_proto.hello = "world";
-    EXPECT_EQ(encoder.WriteString(kNestedProtoHelloField, "world"), Status::OK);
+    EXPECT_EQ(encoder.WriteString(kNestedProtoHelloField, "world"),
+              Status::Ok());
     // nested_proto.id = 999;
-    EXPECT_EQ(encoder.WriteUint32(kNestedProtoIdField, 999), Status::OK);
+    EXPECT_EQ(encoder.WriteUint32(kNestedProtoIdField, 999), Status::Ok());
 
     {
       // DoubleNestedProto& double_nested_proto = nested_proto.append_pair();
-      EXPECT_EQ(encoder.Push(kNestedProtoPairField), Status::OK);
+      EXPECT_EQ(encoder.Push(kNestedProtoPairField), Status::Ok());
       // double_nested_proto.key = "version";
       EXPECT_EQ(encoder.WriteString(kDoubleNestedProtoKeyField, "version"),
-                Status::OK);
+                Status::Ok());
       // double_nested_proto.value = "2.9.1";
       EXPECT_EQ(encoder.WriteString(kDoubleNestedProtoValueField, "2.9.1"),
-                Status::OK);
+                Status::Ok());
 
-      EXPECT_EQ(encoder.Pop(), Status::OK);
+      EXPECT_EQ(encoder.Pop(), Status::Ok());
     }  // end DoubleNestedProto
 
     {
       // DoubleNestedProto& double_nested_proto = nested_proto.append_pair();
-      EXPECT_EQ(encoder.Push(kNestedProtoPairField), Status::OK);
+      EXPECT_EQ(encoder.Push(kNestedProtoPairField), Status::Ok());
       // double_nested_proto.key = "device";
       EXPECT_EQ(encoder.WriteString(kDoubleNestedProtoKeyField, "device"),
-                Status::OK);
+                Status::Ok());
       // double_nested_proto.value = "left-soc";
       EXPECT_EQ(encoder.WriteString(kDoubleNestedProtoValueField, "left-soc"),
-                Status::OK);
+                Status::Ok());
 
-      EXPECT_EQ(encoder.Pop(), Status::OK);
+      EXPECT_EQ(encoder.Pop(), Status::Ok());
     }  // end DoubleNestedProto
 
-    EXPECT_EQ(encoder.Pop(), Status::OK);
+    EXPECT_EQ(encoder.Pop(), Status::Ok());
   }  // end NestedProto
 
   // test_proto.ziggy = -13;
-  EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::OK);
+  EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::Ok());
 
   // clang-format off
   constexpr uint8_t encoded_proto[] = {
@@ -214,7 +215,7 @@
   // clang-format on
 
   std::span<const std::byte> encoded;
-  EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
+  EXPECT_EQ(encoder.Encode(&encoded), Status::Ok());
   EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
   EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
 }
@@ -224,16 +225,16 @@
   NestedEncoder<2, 10> encoder(encode_buffer);
 
   // One level of nesting.
-  EXPECT_EQ(encoder.Push(2), Status::OK);
+  EXPECT_EQ(encoder.Push(2), Status::Ok());
   // Two levels of nesting.
-  EXPECT_EQ(encoder.Push(1), Status::OK);
+  EXPECT_EQ(encoder.Push(1), Status::Ok());
   // Three levels of nesting: error!
-  EXPECT_EQ(encoder.Push(1), Status::RESOURCE_EXHAUSTED);
+  EXPECT_EQ(encoder.Push(1), Status::ResourceExhausted());
 
   // Further operations should fail.
-  EXPECT_EQ(encoder.Pop(), Status::RESOURCE_EXHAUSTED);
-  EXPECT_EQ(encoder.Pop(), Status::RESOURCE_EXHAUSTED);
-  EXPECT_EQ(encoder.Pop(), Status::RESOURCE_EXHAUSTED);
+  EXPECT_EQ(encoder.Pop(), Status::ResourceExhausted());
+  EXPECT_EQ(encoder.Pop(), Status::ResourceExhausted());
+  EXPECT_EQ(encoder.Pop(), Status::ResourceExhausted());
 }
 
 TEST(Encoder, NestedBlobLimit) {
@@ -241,23 +242,23 @@
   NestedEncoder<5, 3> encoder(encode_buffer);
 
   // Write first blob.
-  EXPECT_EQ(encoder.Push(1), Status::OK);
-  EXPECT_EQ(encoder.Pop(), Status::OK);
+  EXPECT_EQ(encoder.Push(1), Status::Ok());
+  EXPECT_EQ(encoder.Pop(), Status::Ok());
 
   // Write second blob.
-  EXPECT_EQ(encoder.Push(2), Status::OK);
+  EXPECT_EQ(encoder.Push(2), Status::Ok());
 
   // Write nested third blob.
-  EXPECT_EQ(encoder.Push(3), Status::OK);
-  EXPECT_EQ(encoder.Pop(), Status::OK);
+  EXPECT_EQ(encoder.Push(3), Status::Ok());
+  EXPECT_EQ(encoder.Pop(), Status::Ok());
 
   // End second blob.
-  EXPECT_EQ(encoder.Pop(), Status::OK);
+  EXPECT_EQ(encoder.Pop(), Status::Ok());
 
   // Write fourth blob: error!.
-  EXPECT_EQ(encoder.Push(4), Status::RESOURCE_EXHAUSTED);
+  EXPECT_EQ(encoder.Push(4), Status::ResourceExhausted());
   // Nothing to pop.
-  EXPECT_EQ(encoder.Pop(), Status::RESOURCE_EXHAUSTED);
+  EXPECT_EQ(encoder.Pop(), Status::ResourceExhausted());
 }
 
 TEST(Encoder, RepeatedField) {
@@ -274,7 +275,7 @@
       0x08, 0x00, 0x08, 0x32, 0x08, 0x64, 0x08, 0x96, 0x01, 0x08, 0xc8, 0x01};
 
   std::span<const std::byte> encoded;
-  EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
+  EXPECT_EQ(encoder.Encode(&encoded), Status::Ok());
   EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
   EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
 }
@@ -292,7 +293,7 @@
   //  key   size  v[0]  v[1]  v[2]  v[3]        v[4]
 
   std::span<const std::byte> encoded;
-  EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
+  EXPECT_EQ(encoder.Encode(&encoded), Status::Ok());
   EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
   EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
 }
@@ -305,7 +306,7 @@
   encoder.WritePackedUint32(1, values);
 
   std::span<const std::byte> encoded;
-  EXPECT_EQ(encoder.Encode(&encoded), Status::RESOURCE_EXHAUSTED);
+  EXPECT_EQ(encoder.Encode(&encoded), Status::ResourceExhausted());
   EXPECT_EQ(encoded.size(), 0u);
 }
 
@@ -327,7 +328,7 @@
       0x12, 0x08, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01};
 
   std::span<const std::byte> encoded;
-  EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
+  EXPECT_EQ(encoder.Encode(&encoded), Status::Ok());
   EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
   EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
 }
@@ -344,7 +345,7 @@
       0x0a, 0x09, 0xc7, 0x01, 0x31, 0x01, 0x00, 0x02, 0x32, 0xc8, 0x01};
 
   std::span<const std::byte> encoded;
-  EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
+  EXPECT_EQ(encoder.Encode(&encoded), Status::Ok());
   EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
   EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
 }
diff --git a/pw_protobuf/find.cc b/pw_protobuf/find.cc
index 923097a..635f50b 100644
--- a/pw_protobuf/find.cc
+++ b/pw_protobuf/find.cc
@@ -20,12 +20,12 @@
                                        uint32_t field_number) {
   if (field_number != field_number_) {
     // Continue to the next field.
-    return Status::OK;
+    return Status::Ok();
   }
 
   found_ = true;
   if (nested_handler_ == nullptr) {
-    return Status::CANCELLED;
+    return Status::Cancelled();
   }
 
   std::span<const std::byte> submessage;
diff --git a/pw_protobuf/public/pw_protobuf/decoder.h b/pw_protobuf/public/pw_protobuf/decoder.h
index 595bc9a..6cb402e 100644
--- a/pw_protobuf/public/pw_protobuf/decoder.h
+++ b/pw_protobuf/public/pw_protobuf/decoder.h
@@ -192,7 +192,7 @@
 //           break;
 //       }
 //
-//       return Status::OK;
+//       return Status::Ok();
 //     }
 //
 //     int bar;
@@ -303,8 +303,8 @@
   // Receives a pointer to the decoder object, allowing the handler to call
   // the appropriate method to extract the field's data.
   //
-  // If the status returned is not Status::OK, the decode operation is exited
-  // with the provided status. Returning Status::CANCELLED allows a convenient
+  // If the status returned is not Status::Ok(), the decode operation is exited
+  // with the provided status. Returning Status::Cancelled() allows a convenient
   // way of stopping a decode early (for example, if a desired field is found).
   virtual Status ProcessField(CallbackDecoder& decoder,
                               uint32_t field_number) = 0;
diff --git a/pw_protobuf/public/pw_protobuf/encoder.h b/pw_protobuf/public/pw_protobuf/encoder.h
index 3e86368..14483d2 100644
--- a/pw_protobuf/public/pw_protobuf/encoder.h
+++ b/pw_protobuf/public/pw_protobuf/encoder.h
@@ -40,7 +40,7 @@
         blob_count_(0),
         blob_stack_(stack),
         depth_(0),
-        encode_status_(Status::OK) {}
+        encode_status_(Status::Ok()) {}
 
   // Disallow copy/assign to avoid confusion about who owns the buffer.
   Encoder(const Encoder& other) = delete;
@@ -259,7 +259,7 @@
   // obtained from Encode().
   void Clear() {
     cursor_ = buffer_.data();
-    encode_status_ = Status::OK;
+    encode_status_ = Status::Ok();
     blob_count_ = 0;
     depth_ = 0;
   }
@@ -278,7 +278,7 @@
   // Encodes the key for a proto field consisting of its number and wire type.
   Status WriteFieldKey(uint32_t field_number, WireType wire_type) {
     if (!ValidFieldNumber(field_number)) {
-      encode_status_ = Status::INVALID_ARGUMENT;
+      encode_status_ = Status::InvalidArgument();
       return encode_status_;
     }
 
diff --git a/pw_random/xor_shift_test.cc b/pw_random/xor_shift_test.cc
index 660c981..6b7e379 100644
--- a/pw_random/xor_shift_test.cc
+++ b/pw_random/xor_shift_test.cc
@@ -44,7 +44,7 @@
   XorShiftStarRng64 rng(seed1);
   for (size_t i = 0; i < result1_count; ++i) {
     uint64_t val = 0;
-    EXPECT_EQ(rng.GetInt(val).status(), Status::OK);
+    EXPECT_EQ(rng.GetInt(val).status(), Status::Ok());
     EXPECT_EQ(val, result1[i]);
   }
 }
@@ -53,7 +53,7 @@
   XorShiftStarRng64 rng(seed2);
   for (size_t i = 0; i < result2_count; ++i) {
     uint64_t val = 0;
-    EXPECT_EQ(rng.GetInt(val).status(), Status::OK);
+    EXPECT_EQ(rng.GetInt(val).status(), Status::Ok());
     EXPECT_EQ(val, result2[i]);
   }
 }
@@ -62,7 +62,7 @@
   XorShiftStarRng64 rng(seed1);
   uint64_t val = 0;
   rng.InjectEntropyBits(0x1, 1);
-  EXPECT_EQ(rng.GetInt(val).status(), Status::OK);
+  EXPECT_EQ(rng.GetInt(val).status(), Status::Ok());
   EXPECT_NE(val, result1[0]);
 }
 
@@ -72,14 +72,14 @@
   XorShiftStarRng64 rng_1(seed1);
   uint64_t first_val = 0;
   rng_1.InjectEntropyBits(0x1, 1);
-  EXPECT_EQ(rng_1.GetInt(first_val).status(), Status::OK);
+  EXPECT_EQ(rng_1.GetInt(first_val).status(), Status::Ok());
 
   // Use the same starting seed.
   XorShiftStarRng64 rng_2(seed1);
   uint64_t second_val = 0;
   // Use a different number of entropy bits.
   rng_2.InjectEntropyBits(0x1, 2);
-  EXPECT_EQ(rng_2.GetInt(second_val).status(), Status::OK);
+  EXPECT_EQ(rng_2.GetInt(second_val).status(), Status::Ok());
 
   EXPECT_NE(first_val, second_val);
 }
@@ -91,7 +91,7 @@
   XorShiftStarRng64 rng_1(seed1);
   uint64_t first_val = 0;
   rng_1.InjectEntropyBits(0x6, 3);
-  EXPECT_EQ(rng_1.GetInt(first_val).status(), Status::OK);
+  EXPECT_EQ(rng_1.GetInt(first_val).status(), Status::Ok());
 
   // Use the same starting seed.
   XorShiftStarRng64 rng_2(seed1);
@@ -100,7 +100,7 @@
   rng_2.InjectEntropyBits(0x1, 1);
   rng_2.InjectEntropyBits(0x1, 1);
   rng_2.InjectEntropyBits(0x0, 1);
-  EXPECT_EQ(rng_2.GetInt(second_val).status(), Status::OK);
+  EXPECT_EQ(rng_2.GetInt(second_val).status(), Status::Ok());
 
   EXPECT_EQ(first_val, second_val);
 }
@@ -114,7 +114,7 @@
                                                    std::byte(0x17),
                                                    std::byte(0x02)};
   rng.InjectEntropy(entropy);
-  EXPECT_EQ(rng.GetInt(val).status(), Status::OK);
+  EXPECT_EQ(rng.GetInt(val).status(), Status::Ok());
   EXPECT_NE(val, result1[0]);
 }
 
diff --git a/pw_result/public/pw_result/result.h b/pw_result/public/pw_result/result.h
index 60bcc05..7093551 100644
--- a/pw_result/public/pw_result/result.h
+++ b/pw_result/public/pw_result/result.h
@@ -26,17 +26,20 @@
 template <typename T>
 class Result {
  public:
-  constexpr Result(T&& value) : value_(std::move(value)), status_(Status::OK) {}
-  constexpr Result(const T& value) : value_(value), status_(Status::OK) {}
+  constexpr Result(T&& value)
+      : value_(std::move(value)), status_(Status::Ok()) {}
+  constexpr Result(const T& value) : value_(value), status_(Status::Ok()) {}
 
   template <typename... Args>
   constexpr Result(std::in_place_t, Args&&... args)
-      : value_(std::forward<Args>(args)...), status_(Status::OK) {}
+      : value_(std::forward<Args>(args)...), status_(Status::Ok()) {}
 
   // TODO(pwbug/246): This can be constexpr when tokenized asserts are fixed.
-  Result(Status status) : status_(status) { PW_CHECK(status_ != Status::OK); }
+  Result(Status status) : status_(status) { PW_CHECK(status_ != Status::Ok()); }
   // TODO(pwbug/246): This can be constexpr when tokenized asserts are fixed.
-  Result(Status::Code code) : status_(code) { PW_CHECK(status_ != Status::OK); }
+  Result(Status::Code code) : status_(code) {
+    PW_CHECK(status_ != Status::Ok());
+  }
 
   constexpr Result(const Result&) = default;
   constexpr Result& operator=(const Result&) = default;
diff --git a/pw_result/result_test.cc b/pw_result/result_test.cc
index b29c240..ef913fd 100644
--- a/pw_result/result_test.cc
+++ b/pw_result/result_test.cc
@@ -22,19 +22,19 @@
 TEST(Result, CreateOk) {
   Result<const char*> res("hello");
   EXPECT_TRUE(res.ok());
-  EXPECT_EQ(res.status(), Status::OK);
+  EXPECT_EQ(res.status(), Status::Ok());
   EXPECT_EQ(res.value(), "hello");
 }
 
 TEST(Result, CreateNotOk) {
-  Result<int> res(Status::DATA_LOSS);
+  Result<int> res(Status::DataLoss());
   EXPECT_FALSE(res.ok());
-  EXPECT_EQ(res.status(), Status::DATA_LOSS);
+  EXPECT_EQ(res.status(), Status::DataLoss());
 }
 
 TEST(Result, ValueOr) {
   Result<int> good(3);
-  Result<int> bad(Status::DATA_LOSS);
+  Result<int> bad(Status::DataLoss());
   EXPECT_EQ(good.value_or(42), 3);
   EXPECT_EQ(bad.value_or(42), 42);
 }
@@ -55,7 +55,7 @@
 
 Result<float> Divide(float a, float b) {
   if (b == 0) {
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
   return a / b;
 }
@@ -69,7 +69,7 @@
 TEST(Divide, ReturnNotOk) {
   Result<float> res = Divide(10, 0);
   EXPECT_FALSE(res.ok());
-  EXPECT_EQ(res.status(), Status::INVALID_ARGUMENT);
+  EXPECT_EQ(res.status(), Status::InvalidArgument());
 }
 
 }  // namespace
diff --git a/pw_result/size_report/pointer_noinline.cc b/pw_result/size_report/pointer_noinline.cc
index 7c77de6..522c9fe 100644
--- a/pw_result/size_report/pointer_noinline.cc
+++ b/pw_result/size_report/pointer_noinline.cc
@@ -18,10 +18,10 @@
 
 PW_NO_INLINE pw::Status Divide(float a, float b, float* out) {
   if (b == 0) {
-    return pw::Status::INVALID_ARGUMENT;
+    return pw::Status::InvalidArgument();
   }
   *out = a / b;
-  return pw::Status::OK;
+  return pw::Status::Ok();
 }
 
 int volatile* unoptimizable;
diff --git a/pw_result/size_report/pointer_read.cc b/pw_result/size_report/pointer_read.cc
index e346452..fb4f948 100644
--- a/pw_result/size_report/pointer_read.cc
+++ b/pw_result/size_report/pointer_read.cc
@@ -34,11 +34,11 @@
                              size_t size,
                              std::span<const std::byte>* out) {
   if (offset + size >= std::size(kArray)) {
-    return pw::Status::OUT_OF_RANGE;
+    return pw::Status::OutOfRange();
   }
 
   *out = std::span<const std::byte>(std::data(kArray) + offset, size);
-  return pw::Status::OK;
+  return pw::Status::Ok();
 }
 
 }  // namespace
diff --git a/pw_result/size_report/pointer_simple.cc b/pw_result/size_report/pointer_simple.cc
index eb536d4..7c1440e 100644
--- a/pw_result/size_report/pointer_simple.cc
+++ b/pw_result/size_report/pointer_simple.cc
@@ -17,10 +17,10 @@
 
 pw::Status Divide(float a, float b, float* out) {
   if (b == 0) {
-    return pw::Status::INVALID_ARGUMENT;
+    return pw::Status::InvalidArgument();
   }
   *out = a / b;
-  return pw::Status::OK;
+  return pw::Status::Ok();
 }
 
 int volatile* unoptimizable;
diff --git a/pw_result/size_report/result_noinline.cc b/pw_result/size_report/result_noinline.cc
index c099dc5..b008e52 100644
--- a/pw_result/size_report/result_noinline.cc
+++ b/pw_result/size_report/result_noinline.cc
@@ -18,7 +18,7 @@
 
 PW_NO_INLINE pw::Result<float> Divide(float a, float b) {
   if (b == 0) {
-    return pw::Status::INVALID_ARGUMENT;
+    return pw::Status::InvalidArgument();
   }
   return a / b;
 }
diff --git a/pw_result/size_report/result_read.cc b/pw_result/size_report/result_read.cc
index 9bc9ffd..351be04 100644
--- a/pw_result/size_report/result_read.cc
+++ b/pw_result/size_report/result_read.cc
@@ -33,7 +33,7 @@
 PW_NO_INLINE pw::Result<std::span<const std::byte>> Read(size_t offset,
                                                          size_t size) {
   if (offset + size >= std::size(kArray)) {
-    return pw::Status::OUT_OF_RANGE;
+    return pw::Status::OutOfRange();
   }
 
   return std::span<const std::byte>(std::data(kArray) + offset, size);
diff --git a/pw_result/size_report/result_simple.cc b/pw_result/size_report/result_simple.cc
index 91772b9..333eca8 100644
--- a/pw_result/size_report/result_simple.cc
+++ b/pw_result/size_report/result_simple.cc
@@ -17,7 +17,7 @@
 
 pw::Result<float> Divide(float a, float b) {
   if (b == 0) {
-    return pw::Status::INVALID_ARGUMENT;
+    return pw::Status::InvalidArgument();
   }
   return a / b;
 }
diff --git a/pw_ring_buffer/prefixed_entry_ring_buffer.cc b/pw_ring_buffer/prefixed_entry_ring_buffer.cc
index 31eb222..d122162 100644
--- a/pw_ring_buffer/prefixed_entry_ring_buffer.cc
+++ b/pw_ring_buffer/prefixed_entry_ring_buffer.cc
@@ -33,24 +33,24 @@
   if ((buffer.data() == nullptr) ||  //
       (buffer.size_bytes() == 0) ||  //
       (buffer.size_bytes() > kMaxBufferBytes)) {
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
 
   buffer_ = buffer.data();
   buffer_bytes_ = buffer.size_bytes();
 
   Clear();
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status PrefixedEntryRingBuffer::InternalPushBack(std::span<const byte> data,
                                                  byte user_preamble_data,
                                                  bool drop_elements_if_needed) {
   if (buffer_ == nullptr) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
   if (data.size_bytes() == 0) {
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
 
   // Prepare the preamble, and ensure we can fit the preamble and entry.
@@ -59,7 +59,7 @@
   size_t total_write_bytes =
       (user_preamble_ ? 1 : 0) + varint_bytes + data.size_bytes();
   if (buffer_bytes_ < total_write_bytes) {
-    return Status::OUT_OF_RANGE;
+    return Status::OutOfRange();
   }
 
   if (drop_elements_if_needed) {
@@ -70,7 +70,7 @@
     }
   } else if (RawAvailableBytes() < total_write_bytes) {
     // TryPushBack() case: don't evict items.
-    return Status::RESOURCE_EXHAUSTED;
+    return Status::ResourceExhausted();
   }
 
   // Write the new entry into the ring buffer.
@@ -80,7 +80,7 @@
   RawWrite(std::span(varint_buf, varint_bytes));
   RawWrite(data);
   entry_count_++;
-  return Status::OK;
+  return Status::Ok();
 }
 
 auto GetOutput(std::span<byte> data_out, size_t* write_index) {
@@ -90,8 +90,8 @@
     memcpy(data_out.data() + *write_index, src.data(), copy_size);
     *write_index += copy_size;
 
-    return (copy_size == src.size_bytes()) ? Status::OK
-                                           : Status::RESOURCE_EXHAUSTED;
+    return (copy_size == src.size_bytes()) ? Status::Ok()
+                                           : Status::ResourceExhausted();
   };
 }
 
@@ -119,10 +119,10 @@
 template <typename T>
 Status PrefixedEntryRingBuffer::InternalRead(T read_output, bool get_preamble) {
   if (buffer_ == nullptr) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
   if (EntryCount() == 0) {
-    return Status::OUT_OF_RANGE;
+    return Status::OutOfRange();
   }
 
   // Figure out where to start reading (wrapped); accounting for preamble.
@@ -150,10 +150,10 @@
 
 Status PrefixedEntryRingBuffer::PopFront() {
   if (buffer_ == nullptr) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
   if (EntryCount() == 0) {
-    return Status::OUT_OF_RANGE;
+    return Status::OutOfRange();
   }
 
   // Advance the read pointer past the front entry to the next one.
@@ -161,16 +161,16 @@
   size_t entry_bytes = info.preamble_bytes + info.data_bytes;
   read_idx_ = IncrementIndex(read_idx_, entry_bytes);
   entry_count_--;
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status PrefixedEntryRingBuffer::Dering() {
   if (buffer_ == nullptr) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
   // Check if by luck we're already deringed.
   if (read_idx_ == 0) {
-    return Status::OK;
+    return Status::Ok();
   }
 
   auto buffer_span = std::span(buffer_, buffer_bytes_);
@@ -184,7 +184,7 @@
   }
   write_idx_ -= read_idx_;
   read_idx_ = 0;
-  return Status::OK;
+  return Status::Ok();
 }
 
 size_t PrefixedEntryRingBuffer::FrontEntryDataSizeBytes() {
diff --git a/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc b/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
index 271ce74..5838ca4 100644
--- a/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
+++ b/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
@@ -35,20 +35,20 @@
 
   EXPECT_EQ(ring.EntryCount(), 0u);
   EXPECT_EQ(ring.SetBuffer(std::span<byte>(nullptr, 10u)),
-            Status::INVALID_ARGUMENT);
-  EXPECT_EQ(ring.SetBuffer(std::span(buf, 0u)), Status::INVALID_ARGUMENT);
+            Status::InvalidArgument());
+  EXPECT_EQ(ring.SetBuffer(std::span(buf, 0u)), Status::InvalidArgument());
   EXPECT_EQ(ring.FrontEntryDataSizeBytes(), 0u);
 
-  EXPECT_EQ(ring.PushBack(buf), Status::FAILED_PRECONDITION);
+  EXPECT_EQ(ring.PushBack(buf), Status::FailedPrecondition());
   EXPECT_EQ(ring.EntryCount(), 0u);
-  EXPECT_EQ(ring.PeekFront(buf, &count), Status::FAILED_PRECONDITION);
+  EXPECT_EQ(ring.PeekFront(buf, &count), Status::FailedPrecondition());
   EXPECT_EQ(count, 0u);
   EXPECT_EQ(ring.EntryCount(), 0u);
   EXPECT_EQ(ring.PeekFrontWithPreamble(buf, &count),
-            Status::FAILED_PRECONDITION);
+            Status::FailedPrecondition());
   EXPECT_EQ(count, 0u);
   EXPECT_EQ(ring.EntryCount(), 0u);
-  EXPECT_EQ(ring.PopFront(), Status::FAILED_PRECONDITION);
+  EXPECT_EQ(ring.PopFront(), Status::FailedPrecondition());
   EXPECT_EQ(ring.EntryCount(), 0u);
 }
 
@@ -83,23 +83,23 @@
   // out and happen to see a previous value.
   size_t read_size = 500U;
 
-  EXPECT_EQ(ring.SetBuffer(test_buffer), Status::OK);
+  EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
 
   EXPECT_EQ(ring.EntryCount(), 0u);
-  EXPECT_EQ(ring.PopFront(), Status::OUT_OF_RANGE);
+  EXPECT_EQ(ring.PopFront(), Status::OutOfRange());
   EXPECT_EQ(ring.EntryCount(), 0u);
   EXPECT_EQ(ring.PushBack(std::span(single_entry_data, 0u)),
-            Status::INVALID_ARGUMENT);
+            Status::InvalidArgument());
   EXPECT_EQ(ring.EntryCount(), 0u);
   EXPECT_EQ(
       ring.PushBack(std::span(single_entry_data, sizeof(test_buffer) + 5)),
-      Status::OUT_OF_RANGE);
+      Status::OutOfRange());
   EXPECT_EQ(ring.EntryCount(), 0u);
-  EXPECT_EQ(ring.PeekFront(read_buffer, &read_size), Status::OUT_OF_RANGE);
+  EXPECT_EQ(ring.PeekFront(read_buffer, &read_size), Status::OutOfRange());
   EXPECT_EQ(read_size, 0u);
   read_size = 500U;
   EXPECT_EQ(ring.PeekFrontWithPreamble(read_buffer, &read_size),
-            Status::OUT_OF_RANGE);
+            Status::OutOfRange());
   EXPECT_EQ(read_size, 0u);
 
   size_t user_preamble_bytes = (user_data ? 1 : 0);
@@ -115,12 +115,12 @@
     ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), 0u);
 
     ASSERT_EQ(ring.PushBack(std::span(single_entry_data, data_size), byte(i)),
-              Status::OK);
+              Status::Ok());
     ASSERT_EQ(ring.FrontEntryDataSizeBytes(), data_size);
     ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), single_entry_total_size);
 
     read_size = 500U;
-    ASSERT_EQ(ring.PeekFront(read_buffer, &read_size), Status::OK);
+    ASSERT_EQ(ring.PeekFront(read_buffer, &read_size), Status::Ok());
     ASSERT_EQ(read_size, data_size);
 
     // ASSERT_THAT(std::span(expect_buffer).last(data_size),
@@ -131,9 +131,10 @@
               0);
 
     read_size = 500U;
-    ASSERT_EQ(ring.PeekFrontWithPreamble(read_buffer, &read_size), Status::OK);
+    ASSERT_EQ(ring.PeekFrontWithPreamble(read_buffer, &read_size),
+              Status::Ok());
     ASSERT_EQ(read_size, single_entry_total_size);
-    ASSERT_EQ(ring.PopFront(), Status::OK);
+    ASSERT_EQ(ring.PopFront(), Status::Ok());
 
     if (user_data) {
       expect_buffer[0] = byte(i);
@@ -167,7 +168,7 @@
   PrefixedEntryRingBuffer ring(user_data);
   byte test_buffer[single_entry_test_buffer_size];
 
-  EXPECT_EQ(ring.SetBuffer(test_buffer), Status::OK);
+  EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
   EXPECT_EQ(ring.EntryCount(), 0u);
 
   constexpr size_t data_size = sizeof(single_entry_data) - (user_data ? 1 : 0);
@@ -181,7 +182,7 @@
     for (j = 0; j < kSingleEntryCycles; j++) {
       memset(write_buffer, j + seed, sizeof(write_buffer));
 
-      ASSERT_EQ(ring.PushBack(write_buffer), Status::OK);
+      ASSERT_EQ(ring.PushBack(write_buffer), Status::Ok());
 
       size_t expected_count = (j < kCountingUpMaxExpectedEntries)
                                   ? j + 1
@@ -195,11 +196,11 @@
       byte read_buffer[sizeof(write_buffer)];
       size_t read_size;
       memset(write_buffer, fill_val + j, sizeof(write_buffer));
-      ASSERT_EQ(ring.PeekFront(read_buffer, &read_size), Status::OK);
+      ASSERT_EQ(ring.PeekFront(read_buffer, &read_size), Status::Ok());
 
       ASSERT_EQ(memcmp(write_buffer, read_buffer, data_size), 0);
 
-      ASSERT_EQ(ring.PopFront(), Status::OK);
+      ASSERT_EQ(ring.PopFront(), Status::Ok());
     }
   }
 }
@@ -221,13 +222,13 @@
   PrefixedEntryRingBuffer ring(user_data);
   byte test_buffer[single_entry_test_buffer_size];
 
-  EXPECT_EQ(ring.SetBuffer(test_buffer), Status::OK);
+  EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
 
   auto output = [](std::span<const byte> src) -> Status {
     for (byte b : src) {
       read_buffer.push_back(b);
     }
-    return Status::OK;
+    return Status::Ok();
   };
 
   size_t user_preamble_bytes = (user_data ? 1 : 0);
@@ -243,12 +244,12 @@
     ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), 0u);
 
     ASSERT_EQ(ring.PushBack(std::span(single_entry_data, data_size), byte(i)),
-              Status::OK);
+              Status::Ok());
     ASSERT_EQ(ring.FrontEntryDataSizeBytes(), data_size);
     ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), single_entry_total_size);
 
     read_buffer.clear();
-    ASSERT_EQ(ring.PeekFront(output), Status::OK);
+    ASSERT_EQ(ring.PeekFront(output), Status::Ok());
     ASSERT_EQ(read_buffer.size(), data_size);
 
     ASSERT_EQ(memcmp(std::span(expect_buffer).last(data_size).data(),
@@ -257,9 +258,9 @@
               0);
 
     read_buffer.clear();
-    ASSERT_EQ(ring.PeekFrontWithPreamble(output), Status::OK);
+    ASSERT_EQ(ring.PeekFrontWithPreamble(output), Status::Ok());
     ASSERT_EQ(read_buffer.size(), single_entry_total_size);
-    ASSERT_EQ(ring.PopFront(), Status::OK);
+    ASSERT_EQ(ring.PopFront(), Status::Ok());
 
     if (user_data) {
       expect_buffer[0] = byte(i);
@@ -292,7 +293,7 @@
   PrefixedEntryRingBuffer ring;
 
   byte test_buffer[kTestBufferSize];
-  EXPECT_EQ(ring.SetBuffer(test_buffer), Status::OK);
+  EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
 
   // Entry data is entry size - preamble (single byte in this case).
   byte single_entry_buffer[kEntrySizeBytes - 1u];
@@ -335,7 +336,7 @@
     EXPECT_EQ(ring.EntryCount(), kTotalEntryCount);
     EXPECT_EQ(expected_result.size(), ring.TotalUsedBytes());
 
-    ASSERT_EQ(ring.Dering(), Status::OK);
+    ASSERT_EQ(ring.Dering(), Status::Ok());
 
     // Check values after doing the dering.
     EXPECT_EQ(ring.EntryCount(), kTotalEntryCount);
@@ -347,11 +348,11 @@
       for (byte b : src) {
         actual_result.push_back(b);
       }
-      return Status::OK;
+      return Status::Ok();
     };
     while (ring.EntryCount()) {
-      ASSERT_EQ(ring.PeekFrontWithPreamble(output), Status::OK);
-      ASSERT_EQ(ring.PopFront(), Status::OK);
+      ASSERT_EQ(ring.PeekFrontWithPreamble(output), Status::Ok());
+      ASSERT_EQ(ring.PopFront(), Status::Ok());
     }
 
     // Ensure the actual result out of the ring buffer matches our manually
@@ -396,7 +397,7 @@
     T item;
   } aliased;
   size_t bytes_read = 0;
-  PW_CHECK_INT_EQ(ring.PeekFront(aliased.buffer, &bytes_read), Status::OK);
+  PW_CHECK_INT_EQ(ring.PeekFront(aliased.buffer, &bytes_read), Status::Ok());
   PW_CHECK_INT_EQ(bytes_read, sizeof(T));
   return aliased.item;
 }
@@ -404,7 +405,7 @@
 TEST(PrefixedEntryRingBuffer, TryPushBack) {
   PrefixedEntryRingBuffer ring;
   byte test_buffer[kTestBufferSize];
-  EXPECT_EQ(ring.SetBuffer(test_buffer), Status::OK);
+  EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
 
   // Fill up the ring buffer with a constant.
   int total_items = 0;
@@ -413,7 +414,7 @@
     if (status.ok()) {
       total_items++;
     } else {
-      EXPECT_EQ(status, Status::RESOURCE_EXHAUSTED);
+      EXPECT_EQ(status, Status::ResourceExhausted());
       break;
     }
   }
@@ -421,13 +422,13 @@
 
   // Should be unable to push more items.
   for (int i = 0; i < total_items; ++i) {
-    EXPECT_EQ(TryPushBack<int>(ring, 100), Status::RESOURCE_EXHAUSTED);
+    EXPECT_EQ(TryPushBack<int>(ring, 100), Status::ResourceExhausted());
     EXPECT_EQ(PeekFront<int>(ring), 5);
   }
 
   // Fill up the ring buffer with a constant.
   for (int i = 0; i < total_items; ++i) {
-    EXPECT_EQ(PushBack<int>(ring, 100), Status::OK);
+    EXPECT_EQ(PushBack<int>(ring, 100), Status::Ok());
   }
   EXPECT_EQ(PeekFront<int>(ring), 100);
 }
diff --git a/pw_rpc/base_server_writer.cc b/pw_rpc/base_server_writer.cc
index 5e33aa9..1e3c396 100644
--- a/pw_rpc/base_server_writer.cc
+++ b/pw_rpc/base_server_writer.cc
@@ -74,7 +74,7 @@
 Status BaseServerWriter::ReleasePayloadBuffer(
     std::span<const std::byte> payload) {
   if (!open()) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
   return call_.channel().Send(response_, ResponsePacket(payload));
 }
diff --git a/pw_rpc/base_server_writer_test.cc b/pw_rpc/base_server_writer_test.cc
index 1a7dae0..bb6b8a2 100644
--- a/pw_rpc/base_server_writer_test.cc
+++ b/pw_rpc/base_server_writer_test.cc
@@ -119,7 +119,7 @@
   EXPECT_EQ(packet.service_id(), context.kServiceId);
   EXPECT_EQ(packet.method_id(), context.get().method().id());
   EXPECT_TRUE(packet.payload().empty());
-  EXPECT_EQ(packet.status(), Status::OK);
+  EXPECT_EQ(packet.status(), Status::Ok());
 }
 
 TEST(ServerWriter, Close) {
@@ -136,11 +136,11 @@
   FakeServerWriter writer(context.get());
 
   constexpr byte data[] = {byte{0xf0}, byte{0x0d}};
-  ASSERT_EQ(Status::OK, writer.Write(data));
+  ASSERT_EQ(Status::Ok(), writer.Write(data));
 
   byte encoded[64];
   auto sws = context.packet(data).Encode(encoded);
-  ASSERT_EQ(Status::OK, sws.status());
+  ASSERT_EQ(Status::Ok(), sws.status());
 
   EXPECT_EQ(sws.size(), context.output().sent_data().size());
   EXPECT_EQ(
@@ -154,7 +154,7 @@
   writer.Finish();
 
   constexpr byte data[] = {byte{0xf0}, byte{0x0d}};
-  EXPECT_EQ(Status::FAILED_PRECONDITION, writer.Write(data));
+  EXPECT_EQ(Status::FailedPrecondition(), writer.Write(data));
 }
 
 }  // namespace
diff --git a/pw_rpc/channel.cc b/pw_rpc/channel.cc
index 1074cea..8771109 100644
--- a/pw_rpc/channel.cc
+++ b/pw_rpc/channel.cc
@@ -34,7 +34,7 @@
   if (!encoded.ok()) {
     PW_LOG_ERROR("Failed to encode response packet to channel buffer");
     output().SendAndReleaseBuffer(0);
-    return Status::INTERNAL;
+    return Status::Internal();
   }
 
   return output().SendAndReleaseBuffer(encoded.size());
diff --git a/pw_rpc/channel_test.cc b/pw_rpc/channel_test.cc
index b160729..cdddc14 100644
--- a/pw_rpc/channel_test.cc
+++ b/pw_rpc/channel_test.cc
@@ -28,7 +28,7 @@
    public:
     NameTester(const char* name) : ChannelOutput(name) {}
     std::span<std::byte> AcquireBuffer() override { return {}; }
-    Status SendAndReleaseBuffer(size_t) override { return Status::OK; }
+    Status SendAndReleaseBuffer(size_t) override { return Status::Ok(); }
   };
 
   EXPECT_STREQ("hello_world", NameTester("hello_world").name());
@@ -59,7 +59,7 @@
   Channel::OutputBuffer output_buffer = channel.AcquireBuffer();
   EXPECT_TRUE(output_buffer.payload(kTestPacket).empty());
 
-  EXPECT_EQ(Status::INTERNAL, channel.Send(output_buffer, kTestPacket));
+  EXPECT_EQ(Status::Internal(), channel.Send(output_buffer, kTestPacket));
 }
 
 TEST(Channel, OutputBuffer_ExactFit) {
@@ -72,7 +72,7 @@
   EXPECT_EQ(payload.size(), output.buffer().size() - kReservedSize);
   EXPECT_EQ(output.buffer().data() + kReservedSize, payload.data());
 
-  EXPECT_EQ(Status::OK, channel.Send(output_buffer, kTestPacket));
+  EXPECT_EQ(Status::Ok(), channel.Send(output_buffer, kTestPacket));
 }
 
 TEST(Channel, OutputBuffer_PayloadDoesNotFit_ReportsError) {
@@ -83,7 +83,7 @@
   byte data[1] = {};
   packet.set_payload(data);
 
-  EXPECT_EQ(Status::INTERNAL, channel.Send(packet));
+  EXPECT_EQ(Status::Internal(), channel.Send(packet));
 }
 
 TEST(Channel, OutputBuffer_ExtraRoom) {
@@ -96,7 +96,7 @@
   EXPECT_EQ(payload.size(), output.buffer().size() - kReservedSize);
   EXPECT_EQ(output.buffer().data() + kReservedSize, payload.data());
 
-  EXPECT_EQ(Status::OK, channel.Send(output_buffer, kTestPacket));
+  EXPECT_EQ(Status::Ok(), channel.Send(output_buffer, kTestPacket));
 }
 
 TEST(Channel, OutputBuffer_ReturnsStatusFromChannelOutputSend) {
@@ -104,9 +104,9 @@
   internal::Channel channel(100, &output);
 
   Channel::OutputBuffer output_buffer = channel.AcquireBuffer();
-  output.set_send_status(Status::ABORTED);
+  output.set_send_status(Status::Aborted());
 
-  EXPECT_EQ(Status::ABORTED, channel.Send(output_buffer, kTestPacket));
+  EXPECT_EQ(Status::Aborted(), channel.Send(output_buffer, kTestPacket));
 }
 
 }  // namespace
diff --git a/pw_rpc/nanopb/codegen_test.cc b/pw_rpc/nanopb/codegen_test.cc
index a65ff9d..10ab42a 100644
--- a/pw_rpc/nanopb/codegen_test.cc
+++ b/pw_rpc/nanopb/codegen_test.cc
@@ -53,28 +53,28 @@
 TEST(NanopbCodegen, InvokeUnaryRpc) {
   TestMethodContext<&test::TestService::TestRpc> context;
 
-  EXPECT_EQ(Status::OK,
-            context.call({.integer = 123, .status_code = Status::OK}));
+  EXPECT_EQ(Status::Ok(),
+            context.call({.integer = 123, .status_code = Status::Ok()}));
 
   EXPECT_EQ(124, context.response().value);
 
   EXPECT_EQ(
-      Status::INVALID_ARGUMENT,
-      context.call({.integer = 999, .status_code = Status::INVALID_ARGUMENT}));
+      Status::InvalidArgument(),
+      context.call({.integer = 999, .status_code = Status::InvalidArgument()}));
   EXPECT_EQ(1000, context.response().value);
 }
 
 TEST(NanopbCodegen, InvokeStreamingRpc) {
   TestMethodContext<&test::TestService::TestStreamRpc> context;
 
-  context.call({.integer = 0, .status_code = Status::ABORTED});
+  context.call({.integer = 0, .status_code = Status::Aborted()});
 
-  EXPECT_EQ(Status::ABORTED, context.status());
+  EXPECT_EQ(Status::Aborted(), context.status());
   EXPECT_TRUE(context.done());
   EXPECT_TRUE(context.responses().empty());
   EXPECT_EQ(0u, context.total_responses());
 
-  context.call({.integer = 4, .status_code = Status::OK});
+  context.call({.integer = 4, .status_code = Status::Ok()});
 
   ASSERT_EQ(4u, context.responses().size());
   ASSERT_EQ(4u, context.total_responses());
@@ -83,7 +83,7 @@
     EXPECT_EQ(context.responses()[i].number, i);
   }
 
-  EXPECT_EQ(Status::OK, context.status());
+  EXPECT_EQ(Status::Ok(), context.status());
 }
 
 TEST(NanopbCodegen, InvokeStreamingRpc_ContextKeepsFixedNumberOfResponses) {
@@ -91,7 +91,7 @@
 
   ASSERT_EQ(3u, context.responses().max_size());
 
-  context.call({.integer = 5, .status_code = Status::NOT_FOUND});
+  context.call({.integer = 5, .status_code = Status::NotFound()});
 
   ASSERT_EQ(3u, context.responses().size());
   ASSERT_EQ(5u, context.total_responses());
@@ -114,9 +114,9 @@
 
   EXPECT_FALSE(context.done());
 
-  writer.Finish(Status::CANCELLED);
+  writer.Finish(Status::Cancelled());
   ASSERT_TRUE(context.done());
-  EXPECT_EQ(Status::CANCELLED, context.status());
+  EXPECT_EQ(Status::Cancelled(), context.status());
 
   ASSERT_EQ(3u, context.responses().size());
   ASSERT_EQ(3u, context.total_responses());
diff --git a/pw_rpc/nanopb/echo_service_test.cc b/pw_rpc/nanopb/echo_service_test.cc
index 4f69533..2d4b6f2 100644
--- a/pw_rpc/nanopb/echo_service_test.cc
+++ b/pw_rpc/nanopb/echo_service_test.cc
@@ -21,13 +21,13 @@
 
 TEST(EchoService, Echo_EchoesRequestMessage) {
   TestMethodContext<&EchoService::Echo> context;
-  ASSERT_EQ(context.call(_pw_rpc_EchoMessage{"Hello, world"}), Status::OK);
+  ASSERT_EQ(context.call(_pw_rpc_EchoMessage{"Hello, world"}), Status::Ok());
   EXPECT_STREQ(context.response().msg, "Hello, world");
 }
 
 TEST(EchoService, Echo_EmptyRequest) {
   TestMethodContext<&EchoService::Echo> context;
-  ASSERT_EQ(context.call({.msg = {}}), Status::OK);
+  ASSERT_EQ(context.call({.msg = {}}), Status::Ok());
   EXPECT_STREQ(context.response().msg, "");
 }
 
diff --git a/pw_rpc/nanopb/nanopb_method.cc b/pw_rpc/nanopb/nanopb_method.cc
index 72a0d7a..bc96dc9 100644
--- a/pw_rpc/nanopb/nanopb_method.cc
+++ b/pw_rpc/nanopb/nanopb_method.cc
@@ -55,7 +55,7 @@
 
   PW_LOG_WARN("Failed to decode request payload from channel %u",
               unsigned(channel.id()));
-  channel.Send(Packet::ServerError(request, Status::DATA_LOSS));
+  channel.Send(Packet::ServerError(request, Status::DataLoss()));
   return false;
 }
 
@@ -80,7 +80,8 @@
 
   PW_LOG_WARN("Failed to encode response packet for channel %u",
               unsigned(channel.id()));
-  channel.Send(response_buffer, Packet::ServerError(request, Status::INTERNAL));
+  channel.Send(response_buffer,
+               Packet::ServerError(request, Status::Internal()));
 }
 
 }  // namespace pw::rpc::internal
diff --git a/pw_rpc/nanopb/nanopb_method_test.cc b/pw_rpc/nanopb/nanopb_method_test.cc
index 31b2397..a98ea50 100644
--- a/pw_rpc/nanopb/nanopb_method_test.cc
+++ b/pw_rpc/nanopb/nanopb_method_test.cc
@@ -77,13 +77,13 @@
                  pw_rpc_test_TestResponse& response) {
     last_request = request;
     response.value = request.integer + 5;
-    return Status::UNAUTHENTICATED;
+    return Status::Unauthenticated();
   }
 
   Status DoNothing(ServerContext&,
                    const pw_rpc_test_Empty&,
                    pw_rpc_test_Empty&) {
-    return Status::UNKNOWN;
+    return Status::Unknown();
   }
 
   void StartStream(ServerContext&,
@@ -103,7 +103,7 @@
   method.Invoke(context.get(), context.packet(request));
 
   const Packet& response = context.output().sent_packet();
-  EXPECT_EQ(response.status(), Status::UNAUTHENTICATED);
+  EXPECT_EQ(response.status(), Status::Unauthenticated());
 
   // Field 1 (encoded as 1 << 3) with 128 as the value.
   constexpr std::byte expected[]{
@@ -125,7 +125,7 @@
 
   const Packet& packet = context.output().sent_packet();
   EXPECT_EQ(PacketType::SERVER_ERROR, packet.type());
-  EXPECT_EQ(Status::DATA_LOSS, packet.status());
+  EXPECT_EQ(Status::DataLoss(), packet.status());
   EXPECT_EQ(context.kServiceId, packet.service_id());
   EXPECT_EQ(method.id(), packet.method_id());
 }
@@ -145,7 +145,7 @@
 
   const Packet& packet = context.output().sent_packet();
   EXPECT_EQ(PacketType::SERVER_ERROR, packet.type());
-  EXPECT_EQ(Status::INTERNAL, packet.status());
+  EXPECT_EQ(Status::Internal(), packet.status());
   EXPECT_EQ(context.kServiceId, packet.service_id());
   EXPECT_EQ(method.id(), packet.method_id());
 
@@ -171,12 +171,12 @@
 
   method.Invoke(context.get(), context.packet({}));
 
-  EXPECT_EQ(Status::OK, last_writer.Write({.value = 100}));
+  EXPECT_EQ(Status::Ok(), last_writer.Write({.value = 100}));
 
   PW_ENCODE_PB(pw_rpc_test_TestResponse, payload, .value = 100);
   std::array<byte, 128> encoded_response = {};
   auto encoded = context.packet(payload).Encode(encoded_response);
-  ASSERT_EQ(Status::OK, encoded.status());
+  ASSERT_EQ(Status::Ok(), encoded.status());
 
   ASSERT_EQ(encoded.size(), context.output().sent_data().size());
   EXPECT_EQ(0,
@@ -200,13 +200,13 @@
   // Verify that the encoded size of a packet with an empty payload is correct.
   std::array<byte, 128> encoded_response = {};
   auto encoded = context.packet({}).Encode(encoded_response);
-  ASSERT_EQ(Status::OK, encoded.status());
+  ASSERT_EQ(Status::Ok(), encoded.status());
   ASSERT_EQ(kNoPayloadPacketSize, encoded.size());
 
   method.Invoke(context.get(), context.packet({}));
 
-  EXPECT_EQ(Status::OK, last_writer.Write({}));                  // Barely fits
-  EXPECT_EQ(Status::INTERNAL, last_writer.Write({.value = 1}));  // Too big
+  EXPECT_EQ(Status::Ok(), last_writer.Write({}));  // Barely fits
+  EXPECT_EQ(Status::Internal(), last_writer.Write({.value = 1}));  // Too big
 }
 
 }  // namespace
diff --git a/pw_rpc/nanopb/public/pw_rpc/echo_service_nanopb.h b/pw_rpc/nanopb/public/pw_rpc/echo_service_nanopb.h
index 0ce388c..127c712 100644
--- a/pw_rpc/nanopb/public/pw_rpc/echo_service_nanopb.h
+++ b/pw_rpc/nanopb/public/pw_rpc/echo_service_nanopb.h
@@ -25,7 +25,7 @@
               const pw_rpc_EchoMessage& request,
               pw_rpc_EchoMessage& response) {
     std::strncpy(response.msg, request.msg, sizeof(response.msg));
-    return Status::OK;
+    return Status::Ok();
   }
 };
 
diff --git a/pw_rpc/nanopb/public/pw_rpc/internal/nanopb_method.h b/pw_rpc/nanopb/public/pw_rpc/internal/nanopb_method.h
index 3a1508c..3a97cff 100644
--- a/pw_rpc/nanopb/public/pw_rpc/internal/nanopb_method.h
+++ b/pw_rpc/nanopb/public/pw_rpc/internal/nanopb_method.h
@@ -300,7 +300,7 @@
   }
 
   ReleasePayloadBuffer({});
-  return Status::INTERNAL;
+  return Status::Internal();
 }
 
 }  // namespace pw::rpc
diff --git a/pw_rpc/nanopb/public/pw_rpc/test_method_context.h b/pw_rpc/nanopb/public/pw_rpc/test_method_context.h
index 07fdd3c..c30941b 100644
--- a/pw_rpc/nanopb/public/pw_rpc/test_method_context.h
+++ b/pw_rpc/nanopb/public/pw_rpc/test_method_context.h
@@ -36,7 +36,7 @@
 // struct can be accessed via context.response().
 //
 //   pw::rpc::TestMethodContext<&my::CoolService::TheMethod> context;
-//   EXPECT_EQ(Status::OK, context.call({.some_arg = 123}));
+//   EXPECT_EQ(Status::Ok(), context.call({.some_arg = 123}));
 //   EXPECT_EQ(500, context.response().some_response_value);
 //
 // For a server streaming RPC, context.call(request) invokes the method. As in a
@@ -47,7 +47,7 @@
 //   context.call({.some_arg = 123});
 //
 //   EXPECT_TRUE(context.done());  // Check that the RPC completed
-//   EXPECT_EQ(Status::OK, context.status());  // Check the status
+//   EXPECT_EQ(Status::Ok(), context.status());  // Check the status
 //
 //   EXPECT_EQ(3u, context.responses().size());
 //   EXPECT_EQ(123, context.responses()[0].value); // check individual responses
@@ -237,7 +237,7 @@
   responses_.clear();
   total_responses_ = 0;
   stream_ended_ = false;
-  last_status_ = Status::UNKNOWN;
+  last_status_ = Status::Unknown();
 }
 
 template <typename Response>
@@ -245,7 +245,7 @@
   PW_CHECK(!stream_ended_);
 
   if (size == 0u) {
-    return Status::OK;
+    return Status::Ok();
   }
 
   internal::Packet packet;
@@ -268,7 +268,7 @@
     default:
       PW_CRASH("Unhandled PacketType");
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 }  // namespace internal::test
diff --git a/pw_rpc/packet.cc b/pw_rpc/packet.cc
index dfbdb50..56969ca 100644
--- a/pw_rpc/packet.cc
+++ b/pw_rpc/packet.cc
@@ -64,7 +64,7 @@
     }
   }
 
-  return status == Status::DATA_LOSS ? Status::DATA_LOSS : Status::OK;
+  return status == Status::DataLoss() ? Status::DataLoss() : Status::Ok();
 }
 
 StatusWithSize Packet::Encode(std::span<byte> buffer) const {
diff --git a/pw_rpc/packet_test.cc b/pw_rpc/packet_test.cc
index 44b2df9..2fd53a2 100644
--- a/pw_rpc/packet_test.cc
+++ b/pw_rpc/packet_test.cc
@@ -87,12 +87,12 @@
 
   auto sws = packet.Encode(buffer);
   EXPECT_EQ(0u, sws.size());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sws.status());
+  EXPECT_EQ(Status::ResourceExhausted(), sws.status());
 }
 
 TEST(Packet, Decode_ValidPacket) {
   Packet packet;
-  ASSERT_EQ(Status::OK, Packet::FromBuffer(kEncoded, packet));
+  ASSERT_EQ(Status::Ok(), Packet::FromBuffer(kEncoded, packet));
 
   EXPECT_EQ(PacketType::RESPONSE, packet.type());
   EXPECT_EQ(1u, packet.channel_id());
@@ -108,7 +108,7 @@
   byte bad_data[] = {byte{0xFF}, byte{0x00}, byte{0x00}, byte{0xFF}};
 
   Packet packet;
-  EXPECT_EQ(Status::DATA_LOSS, Packet::FromBuffer(bad_data, packet));
+  EXPECT_EQ(Status::DataLoss(), Packet::FromBuffer(bad_data, packet));
 }
 
 TEST(Packet, EncodeDecode) {
@@ -119,15 +119,15 @@
   packet.set_service_id(0xdeadbeef);
   packet.set_method_id(0x03a82921);
   packet.set_payload(payload);
-  packet.set_status(Status::UNAVAILABLE);
+  packet.set_status(Status::Unavailable());
 
   byte buffer[128];
   StatusWithSize sws = packet.Encode(buffer);
-  ASSERT_EQ(sws.status(), Status::OK);
+  ASSERT_EQ(sws.status(), Status::Ok());
 
   std::span<byte> packet_data(buffer, sws.size());
   Packet decoded;
-  ASSERT_EQ(Status::OK, Packet::FromBuffer(packet_data, decoded));
+  ASSERT_EQ(Status::Ok(), Packet::FromBuffer(packet_data, decoded));
 
   EXPECT_EQ(decoded.type(), packet.type());
   EXPECT_EQ(decoded.channel_id(), packet.channel_id());
@@ -138,7 +138,7 @@
                         packet.payload().data(),
                         packet.payload().size()),
             0);
-  EXPECT_EQ(decoded.status(), Status::UNAVAILABLE);
+  EXPECT_EQ(decoded.status(), Status::Unavailable());
 }
 
 constexpr size_t kReservedSize = 2 /* type */ + 2 /* channel */ +
diff --git a/pw_rpc/public/pw_rpc/internal/base_server_writer.h b/pw_rpc/public/pw_rpc/internal/base_server_writer.h
index 1ace1e6..295cd4c 100644
--- a/pw_rpc/public/pw_rpc/internal/base_server_writer.h
+++ b/pw_rpc/public/pw_rpc/internal/base_server_writer.h
@@ -53,7 +53,7 @@
   uint32_t method_id() const;
 
   // Closes the ServerWriter, if it is open.
-  void Finish(Status status = Status::OK);
+  void Finish(Status status = Status::Ok());
 
  protected:
   constexpr BaseServerWriter() : state_{kClosed} {}
diff --git a/pw_rpc/public/pw_rpc/internal/packet.h b/pw_rpc/public/pw_rpc/internal/packet.h
index a6feddf..f881187 100644
--- a/pw_rpc/public/pw_rpc/internal/packet.h
+++ b/pw_rpc/public/pw_rpc/internal/packet.h
@@ -33,7 +33,7 @@
   // Creates an RPC packet with the channel, service, and method ID of the
   // provided packet.
   static constexpr Packet Response(const Packet& request,
-                                   Status status = Status::OK) {
+                                   Status status = Status::Ok()) {
     return Packet(PacketType::RESPONSE,
                   request.channel_id(),
                   request.service_id(),
@@ -62,7 +62,7 @@
                    uint32_t service_id,
                    uint32_t method_id,
                    std::span<const std::byte> payload = {},
-                   Status status = Status::OK)
+                   Status status = Status::Ok())
       : type_(type),
         channel_id_(channel_id),
         service_id_(service_id),
diff --git a/pw_rpc/pw_rpc_private/internal_test_utils.h b/pw_rpc/pw_rpc_private/internal_test_utils.h
index c3f958d..aeb2237 100644
--- a/pw_rpc/pw_rpc_private/internal_test_utils.h
+++ b/pw_rpc/pw_rpc_private/internal_test_utils.h
@@ -41,13 +41,13 @@
 
   Status SendAndReleaseBuffer(size_t size) override {
     if (size == 0u) {
-      return Status::OK;
+      return Status::Ok();
     }
 
     packet_count_ += 1;
     sent_data_ = std::span(buffer_.data(), size);
     Status status = internal::Packet::FromBuffer(sent_data_, sent_packet_);
-    EXPECT_EQ(Status::OK, status);
+    EXPECT_EQ(Status::Ok(), status);
     return send_status_;
   }
 
@@ -106,7 +106,7 @@
                             kServiceId,
                             context_.method().id(),
                             payload,
-                            Status::OK);
+                            Status::Ok());
   }
 
   internal::ServerCall& get() { return context_; }
@@ -144,13 +144,13 @@
   // Sends a packet to be processed by the client. Returns the client's
   // ProcessPacket status.
   Status SendPacket(internal::PacketType type,
-                    Status status = Status::OK,
+                    Status status = Status::Ok(),
                     std::span<const std::byte> payload = {}) {
     internal::Packet packet(
         type, kChannelId, kServiceId, kMethodId, payload, status);
     std::byte buffer[input_buffer_size];
     StatusWithSize sws = packet.Encode(buffer);
-    EXPECT_EQ(sws.status(), Status::OK);
+    EXPECT_EQ(sws.status(), Status::Ok());
     return client_.ProcessPacket(std::span(buffer, sws.size()));
   }
 
diff --git a/pw_rpc/server.cc b/pw_rpc/server.cc
index 109221d..f7afeea 100644
--- a/pw_rpc/server.cc
+++ b/pw_rpc/server.cc
@@ -45,7 +45,7 @@
     // Only send an ERROR response if a valid channel ID was provided.
     if (packet.channel_id() != Channel::kUnassignedChannelId) {
       internal::Channel temp_channel(packet.channel_id(), &interface);
-      temp_channel.Send(Packet::ServerError(packet, Status::DATA_LOSS));
+      temp_channel.Send(Packet::ServerError(packet, Status::DataLoss()));
     }
     return false;
   }
@@ -67,11 +67,11 @@
                              ChannelOutput& interface) {
   Packet packet;
   if (!DecodePacket(interface, data, packet)) {
-    return Status::DATA_LOSS;
+    return Status::DataLoss();
   }
 
   if (packet.destination() != Packet::kServer) {
-    return Status::INVALID_ARGUMENT;
+    return Status::InvalidArgument();
   }
 
   internal::Channel* channel = FindChannel(packet.channel_id());
@@ -82,16 +82,16 @@
       // If a channel can't be assigned, send a RESOURCE_EXHAUSTED error.
       internal::Channel temp_channel(packet.channel_id(), &interface);
       temp_channel.Send(
-          Packet::ServerError(packet, Status::RESOURCE_EXHAUSTED));
-      return Status::OK;  // OK since the packet was handled
+          Packet::ServerError(packet, Status::ResourceExhausted()));
+      return Status::Ok();  // OK since the packet was handled
     }
   }
 
   const auto [service, method] = FindMethod(packet);
 
   if (method == nullptr) {
-    channel->Send(Packet::ServerError(packet, Status::NOT_FOUND));
-    return Status::OK;
+    channel->Send(Packet::ServerError(packet, Status::NotFound()));
+    return Status::Ok();
   }
 
   switch (packet.type()) {
@@ -112,11 +112,11 @@
       HandleCancelPacket(packet, *channel);
       break;
     default:
-      channel->Send(Packet::ServerError(packet, Status::UNIMPLEMENTED));
+      channel->Send(Packet::ServerError(packet, Status::Unimplemented()));
       PW_LOG_WARN("Unable to handle packet of type %u",
                   unsigned(packet.type()));
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 std::tuple<Service*, const internal::Method*> Server::FindMethod(
@@ -142,10 +142,10 @@
   });
 
   if (writer == writers_.end()) {
-    channel.Send(Packet::ServerError(packet, Status::FAILED_PRECONDITION));
+    channel.Send(Packet::ServerError(packet, Status::FailedPrecondition()));
     PW_LOG_WARN("Received CANCEL packet for method that is not pending");
   } else {
-    writer->Finish(Status::CANCELLED);
+    writer->Finish(Status::Cancelled());
   }
 }
 
diff --git a/pw_rpc/server_test.cc b/pw_rpc/server_test.cc
index 7c7a0fd..44a7888 100644
--- a/pw_rpc/server_test.cc
+++ b/pw_rpc/server_test.cc
@@ -81,7 +81,7 @@
       std::span<const byte> payload = kDefaultPayload) {
     auto sws = Packet(type, channel_id, service_id, method_id, payload)
                    .Encode(request_buffer_);
-    EXPECT_EQ(Status::OK, sws.status());
+    EXPECT_EQ(Status::Ok(), sws.status());
     return std::span(request_buffer_, sws.size());
   }
 
@@ -95,7 +95,7 @@
 };
 
 TEST_F(BasicServer, ProcessPacket_ValidMethod_InvokesMethod) {
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(Status::Ok(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::REQUEST, 1, 42, 100), output_));
 
@@ -109,13 +109,13 @@
 }
 
 TEST_F(BasicServer, ProcessPacket_IncompletePacket_NothingIsInvoked) {
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::REQUEST, 0, 42, 101), output_));
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 0, 101),
                                   output_));
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 42, 0),
                                   output_));
 
@@ -124,7 +124,7 @@
 }
 
 TEST_F(BasicServer, ProcessPacket_NoChannel_SendsNothing) {
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::REQUEST, 0, 42, 101), output_));
 
@@ -132,25 +132,25 @@
 }
 
 TEST_F(BasicServer, ProcessPacket_NoService_SendsDataLoss) {
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 0, 101),
                                   output_));
 
   EXPECT_EQ(output_.sent_packet().type(), PacketType::SERVER_ERROR);
-  EXPECT_EQ(output_.sent_packet().status(), Status::DATA_LOSS);
+  EXPECT_EQ(output_.sent_packet().status(), Status::DataLoss());
 }
 
 TEST_F(BasicServer, ProcessPacket_NoMethod_SendsDataLoss) {
-  EXPECT_EQ(Status::DATA_LOSS,
+  EXPECT_EQ(Status::DataLoss(),
             server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 42, 0),
                                   output_));
 
   EXPECT_EQ(output_.sent_packet().type(), PacketType::SERVER_ERROR);
-  EXPECT_EQ(output_.sent_packet().status(), Status::DATA_LOSS);
+  EXPECT_EQ(output_.sent_packet().status(), Status::DataLoss());
 }
 
 TEST_F(BasicServer, ProcessPacket_InvalidMethod_NothingIsInvoked) {
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(Status::Ok(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::REQUEST, 1, 42, 101), output_));
 
@@ -159,7 +159,7 @@
 }
 
 TEST_F(BasicServer, ProcessPacket_InvalidMethod_SendsError) {
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(Status::Ok(),
             server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 42, 27),
                                   output_));
 
@@ -168,11 +168,11 @@
   EXPECT_EQ(packet.channel_id(), 1u);
   EXPECT_EQ(packet.service_id(), 42u);
   EXPECT_EQ(packet.method_id(), 27u);  // No method ID 27
-  EXPECT_EQ(packet.status(), Status::NOT_FOUND);
+  EXPECT_EQ(packet.status(), Status::NotFound());
 }
 
 TEST_F(BasicServer, ProcessPacket_InvalidService_SendsError) {
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(Status::Ok(),
             server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 43, 27),
                                   output_));
 
@@ -181,12 +181,12 @@
   EXPECT_EQ(packet.channel_id(), 1u);
   EXPECT_EQ(packet.service_id(), 43u);  // No service ID 43
   EXPECT_EQ(packet.method_id(), 27u);
-  EXPECT_EQ(packet.status(), Status::NOT_FOUND);
+  EXPECT_EQ(packet.status(), Status::NotFound());
 }
 
 TEST_F(BasicServer, ProcessPacket_UnassignedChannel_AssignsToAvailableSlot) {
   TestOutput<128> unassigned_output;
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(Status::Ok(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::REQUEST, /*channel_id=*/99, 42, 100),
                 unassigned_output));
@@ -197,13 +197,13 @@
        ProcessPacket_UnassignedChannel_SendsResourceExhaustedIfCannotAssign) {
   channels_[2] = Channel::Create<3>(&output_);  // Occupy only available channel
 
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(Status::Ok(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::REQUEST, /*channel_id=*/99, 42, 27),
                 output_));
 
   const Packet& packet = output_.sent_packet();
-  EXPECT_EQ(packet.status(), Status::RESOURCE_EXHAUSTED);
+  EXPECT_EQ(packet.status(), Status::ResourceExhausted());
   EXPECT_EQ(packet.channel_id(), 99u);
   EXPECT_EQ(packet.service_id(), 42u);
   EXPECT_EQ(packet.method_id(), 27u);
@@ -211,7 +211,7 @@
 
 TEST_F(BasicServer, ProcessPacket_Cancel_MethodNotActive_SendsError) {
   // Set up a fake ServerWriter representing an ongoing RPC.
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(Status::Ok(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 42, 100),
                 output_));
@@ -221,7 +221,7 @@
   EXPECT_EQ(packet.channel_id(), 1u);
   EXPECT_EQ(packet.service_id(), 42u);
   EXPECT_EQ(packet.method_id(), 100u);
-  EXPECT_EQ(packet.status(), Status::FAILED_PRECONDITION);
+  EXPECT_EQ(packet.status(), Status::FailedPrecondition());
 }
 
 class MethodPending : public BasicServer {
@@ -240,7 +240,7 @@
 };
 
 TEST_F(MethodPending, ProcessPacket_Cancel_ClosesServerWriter) {
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(Status::Ok(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 42, 100),
                 output_));
@@ -249,7 +249,7 @@
 }
 
 TEST_F(MethodPending, ProcessPacket_Cancel_SendsStreamEndPacket) {
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(Status::Ok(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 42, 100),
                 output_));
@@ -260,40 +260,40 @@
   EXPECT_EQ(packet.service_id(), 42u);
   EXPECT_EQ(packet.method_id(), 100u);
   EXPECT_TRUE(packet.payload().empty());
-  EXPECT_EQ(packet.status(), Status::CANCELLED);
+  EXPECT_EQ(packet.status(), Status::Cancelled());
 }
 
 TEST_F(MethodPending, ProcessPacket_Cancel_IncorrectChannel) {
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(Status::Ok(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 2, 42, 100),
                 output_));
 
   EXPECT_EQ(output_.sent_packet().type(), PacketType::SERVER_ERROR);
-  EXPECT_EQ(output_.sent_packet().status(), Status::FAILED_PRECONDITION);
+  EXPECT_EQ(output_.sent_packet().status(), Status::FailedPrecondition());
   EXPECT_TRUE(writer_.open());
 }
 
 TEST_F(MethodPending, ProcessPacket_Cancel_IncorrectService) {
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(Status::Ok(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 43, 100),
                 output_));
 
   EXPECT_EQ(output_.sent_packet().type(), PacketType::SERVER_ERROR);
-  EXPECT_EQ(output_.sent_packet().status(), Status::NOT_FOUND);
+  EXPECT_EQ(output_.sent_packet().status(), Status::NotFound());
   EXPECT_EQ(output_.sent_packet().service_id(), 43u);
   EXPECT_EQ(output_.sent_packet().method_id(), 100u);
   EXPECT_TRUE(writer_.open());
 }
 
 TEST_F(MethodPending, ProcessPacket_CancelIncorrectMethod) {
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(Status::Ok(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 42, 101),
                 output_));
   EXPECT_EQ(output_.sent_packet().type(), PacketType::SERVER_ERROR);
-  EXPECT_EQ(output_.sent_packet().status(), Status::NOT_FOUND);
+  EXPECT_EQ(output_.sent_packet().status(), Status::NotFound());
   EXPECT_TRUE(writer_.open());
 }
 
diff --git a/pw_status/public/pw_status/status.h b/pw_status/public/pw_status/status.h
index d4c591e..2a46335 100644
--- a/pw_status/public/pw_status/status.h
+++ b/pw_status/public/pw_status/status.h
@@ -27,39 +27,39 @@
 // pw_Status uses the canonical Google error codes. The following was copied
 // from Tensorflow and prefixed with PW_STATUS_.
 typedef enum {
-  PW_STATUS_OK = 0,  // Use Status::OK in C++
+  PW_STATUS_OK = 0,  // Use Status::Ok() in C++
 
   // The operation was cancelled (typically by the caller).
-  PW_STATUS_CANCELLED = 1,  // Use Status::CANCELLED in C++
+  PW_STATUS_CANCELLED = 1,  // Use Status::Cancelled() in C++
 
   // Unknown error.  An example of where this error may be returned is
   // if a Status value received from another address space belongs to
   // an error-space that is not known in this address space.  Also,
   // errors raised by APIs that do not return enough error information
   // may be converted to this error.
-  PW_STATUS_UNKNOWN = 2,  // Use Status::UNKNOWN in C++
+  PW_STATUS_UNKNOWN = 2,  // Use Status::Unknown() in C++
 
   // Client specified an invalid argument.  Note that this differs
   // from FAILED_PRECONDITION.  INVALID_ARGUMENT indicates arguments
   // that are problematic regardless of the state of the system
   // (e.g. a malformed file name).
-  PW_STATUS_INVALID_ARGUMENT = 3,  // Use Status::INVALID_ARGUMENT in C++
+  PW_STATUS_INVALID_ARGUMENT = 3,  // Use Status::InvalidArgument() in C++
 
   // Deadline expired before operation could complete.  For operations
   // that change the state of the system, this error may be returned
   // even if the operation has completed successfully.  For example, a
   // successful response from a server could have been delayed long
   // enough for the deadline to expire.
-  PW_STATUS_DEADLINE_EXCEEDED = 4,  // Use Status::DEADLINE_EXCEEDED in C++
+  PW_STATUS_DEADLINE_EXCEEDED = 4,  // Use Status::DeadlineExceeded() in C++
 
   // Some requested entity (e.g. file or directory) was not found.
   // For privacy reasons, this code *may* be returned when the client
   // does not have the access right to the entity.
-  PW_STATUS_NOT_FOUND = 5,  // Use Status::NOT_FOUND in C++
+  PW_STATUS_NOT_FOUND = 5,  // Use Status::NotFound() in C++
 
   // Some entity that we attempted to create (e.g. file or directory)
   // already exists.
-  PW_STATUS_ALREADY_EXISTS = 6,  // Use Status::ALREADY_EXISTS in C++
+  PW_STATUS_ALREADY_EXISTS = 6,  // Use Status::AlreadyExists() in C++
 
   // The caller does not have permission to execute the specified
   // operation.  PERMISSION_DENIED must not be used for rejections
@@ -67,15 +67,15 @@
   // instead for those errors).  PERMISSION_DENIED must not be
   // used if the caller cannot be identified (use UNAUTHENTICATED
   // instead for those errors).
-  PW_STATUS_PERMISSION_DENIED = 7,  // Use Status::PERMISSION_DENIED in C++
+  PW_STATUS_PERMISSION_DENIED = 7,  // Use Status::PermissionDenied() in C++
 
   // The request does not have valid authentication credentials for the
   // operation.
-  PW_STATUS_UNAUTHENTICATED = 16,  // Use Status::UNAUTHENTICATED in C++
+  PW_STATUS_UNAUTHENTICATED = 16,  // Use Status::Unauthenticated() in C++
 
   // Some resource has been exhausted, perhaps a per-user quota, or
   // perhaps the entire filesystem is out of space.
-  PW_STATUS_RESOURCE_EXHAUSTED = 8,  // Use Status::RESOURCE_EXHAUSTED in C++
+  PW_STATUS_RESOURCE_EXHAUSTED = 8,  // Use Status::ResourceExhausted() in C++
 
   // Operation was rejected because the system is not in a state
   // required for the operation's execution.  For example, directory
@@ -96,14 +96,14 @@
   //      REST Get/Update/Delete on a resource and the resource on the
   //      server does not match the condition. E.g. conflicting
   //      read-modify-write on the same resource.
-  PW_STATUS_FAILED_PRECONDITION = 9,  // Use Status::FAILED_PRECONDITION in C++
+  PW_STATUS_FAILED_PRECONDITION = 9,  // Use Status::FailedPrecondition() in C++
 
   // The operation was aborted, typically due to a concurrency issue
   // like sequencer check failures, transaction aborts, etc.
   //
   // See litmus test above for deciding between FAILED_PRECONDITION,
   // ABORTED, and UNAVAILABLE.
-  PW_STATUS_ABORTED = 10,  // Use Status::ABORTED in C++
+  PW_STATUS_ABORTED = 10,  // Use Status::Aborted() in C++
 
   // Operation tried to iterate past the valid input range.  E.g. seeking or
   // reading past end of file.
@@ -120,15 +120,15 @@
   // error) when it applies so that callers who are iterating through
   // a space can easily look for an OUT_OF_RANGE error to detect when
   // they are done.
-  PW_STATUS_OUT_OF_RANGE = 11,  // Use Status::OUT_OF_RANGE in C++
+  PW_STATUS_OUT_OF_RANGE = 11,  // Use Status::OutOfRange() in C++
 
   // Operation is not implemented or not supported/enabled in this service.
-  PW_STATUS_UNIMPLEMENTED = 12,  // Use Status::UNIMPLEMENTED in C++
+  PW_STATUS_UNIMPLEMENTED = 12,  // Use Status::Unimplemented() in C++
 
   // Internal errors.  Means some invariants expected by underlying
   // system has been broken.  If you see one of these errors,
   // something is very broken.
-  PW_STATUS_INTERNAL = 13,  // Use Status::INTERNAL in C++
+  PW_STATUS_INTERNAL = 13,  // Use Status::Internal() in C++
 
   // The service is currently unavailable.  This is a most likely a
   // transient condition and may be corrected by retrying with
@@ -136,10 +136,10 @@
   //
   // See litmus test above for deciding between FAILED_PRECONDITION,
   // ABORTED, and UNAVAILABLE.
-  PW_STATUS_UNAVAILABLE = 14,  // Use Status::UNAVAILABLE in C++
+  PW_STATUS_UNAVAILABLE = 14,  // Use Status::Unavailable() in C++
 
   // Unrecoverable data loss or corruption.
-  PW_STATUS_DATA_LOSS = 15,  // Use Status::DATA_LOSS in C++
+  PW_STATUS_DATA_LOSS = 15,  // Use Status::DataLoss() in C++
 
   // An extra enum entry to prevent people from writing code that
   // fails to compile when a new code is added.
@@ -194,14 +194,14 @@
 namespace pw {
 
 // The Status class is a thin, zero-cost abstraction around the pw_Status enum.
-// It initializes to Status::OK by default and adds ok() and str() methods.
+// It initializes to Status::Ok() by default and adds ok() and str() methods.
 // Implicit conversions are permitted between pw_Status and pw::Status.
 class Status {
  public:
   using Code = pw_Status;
 
   // All of the pw_Status codes are available in the Status class as, e.g.
-  // pw::Status::OK or pw::Status::OUT_OF_RANGE.
+  // pw::Status::Ok() or pw::Status::OutOfRange().
   //
   // These aliases are DEPRECATED -- prefer using the helper functions below.
   // For example, change Status::CANCELLED to Status::Cancelled().
@@ -289,7 +289,7 @@
   // Status implicitly converts to a Status::Code.
   constexpr operator Code() const { return code_; }
 
-  // True if the status is Status::OK.
+  // True if the status is Status::Ok().
   constexpr bool ok() const { return code_ == PW_STATUS_OK; }
 
   // Returns a null-terminated string representation of the Status.
diff --git a/pw_status/public/pw_status/status_with_size.h b/pw_status/public/pw_status/status_with_size.h
index 6064dc3..8c79e8c 100644
--- a/pw_status/public/pw_status/status_with_size.h
+++ b/pw_status/public/pw_status/status_with_size.h
@@ -75,28 +75,28 @@
  public:
   // Non-OK StatusWithSizes can be constructed from these constants, such as:
   //
-  //   StatusWithSize result = StatusWithSize::NOT_FOUND;
+  //   StatusWithSize result = StatusWithSize::NotFound();
   //
   // These constants are DEPRECATED! Use the helper functions below instead. For
-  // example, change StatusWithSize::NOT_FOUND to StatusWithSize::NotFound().
+  // example, change StatusWithSize::NotFound() to StatusWithSize::NotFound().
   //
   // TODO(pwbug/268): Migrate to the functions and remove these constants.
-  static constexpr Constant CANCELLED{Status::CANCELLED};
-  static constexpr Constant UNKNOWN{Status::UNKNOWN};
-  static constexpr Constant INVALID_ARGUMENT{Status::INVALID_ARGUMENT};
-  static constexpr Constant DEADLINE_EXCEEDED{Status::DEADLINE_EXCEEDED};
-  static constexpr Constant NOT_FOUND{Status::NOT_FOUND};
-  static constexpr Constant ALREADY_EXISTS{Status::ALREADY_EXISTS};
-  static constexpr Constant PERMISSION_DENIED{Status::PERMISSION_DENIED};
-  static constexpr Constant RESOURCE_EXHAUSTED{Status::RESOURCE_EXHAUSTED};
-  static constexpr Constant FAILED_PRECONDITION{Status::FAILED_PRECONDITION};
-  static constexpr Constant ABORTED{Status::ABORTED};
-  static constexpr Constant OUT_OF_RANGE{Status::OUT_OF_RANGE};
-  static constexpr Constant UNIMPLEMENTED{Status::UNIMPLEMENTED};
-  static constexpr Constant INTERNAL{Status::INTERNAL};
-  static constexpr Constant UNAVAILABLE{Status::UNAVAILABLE};
-  static constexpr Constant DATA_LOSS{Status::DATA_LOSS};
-  static constexpr Constant UNAUTHENTICATED{Status::UNAUTHENTICATED};
+  static constexpr Constant CANCELLED{Status::Cancelled()};
+  static constexpr Constant UNKNOWN{Status::Unknown()};
+  static constexpr Constant INVALID_ARGUMENT{Status::InvalidArgument()};
+  static constexpr Constant DEADLINE_EXCEEDED{Status::DeadlineExceeded()};
+  static constexpr Constant NOT_FOUND{Status::NotFound()};
+  static constexpr Constant ALREADY_EXISTS{Status::AlreadyExists()};
+  static constexpr Constant PERMISSION_DENIED{Status::PermissionDenied()};
+  static constexpr Constant RESOURCE_EXHAUSTED{Status::ResourceExhausted()};
+  static constexpr Constant FAILED_PRECONDITION{Status::FailedPrecondition()};
+  static constexpr Constant ABORTED{Status::Aborted()};
+  static constexpr Constant OUT_OF_RANGE{Status::OutOfRange()};
+  static constexpr Constant UNIMPLEMENTED{Status::Unimplemented()};
+  static constexpr Constant INTERNAL{Status::Internal()};
+  static constexpr Constant UNAVAILABLE{Status::Unavailable()};
+  static constexpr Constant DATA_LOSS{Status::DataLoss()};
+  static constexpr Constant UNAUTHENTICATED{Status::Unauthenticated()};
 
   // Functions that create a StatusWithSize with the specified status code. For
   // codes other than OK, the size defaults to 0.
@@ -177,7 +177,7 @@
   // The maximum valid value for size.
   static constexpr size_t max_size() { return kSizeMask; }
 
-  // True if status() == Status::OK.
+  // True if status() == Status::Ok().
   constexpr bool ok() const { return (size_ & kStatusMask) == 0u; }
 
   constexpr Status status() const {
diff --git a/pw_status/try_test.cc b/pw_status/try_test.cc
index 4d52e5a..b84258b 100644
--- a/pw_status/try_test.cc
+++ b/pw_status/try_test.cc
@@ -26,7 +26,7 @@
   PW_TRY(ReturnStatus(status));
 
   // Any status other than OK should have already returned.
-  EXPECT_EQ(status, Status::OK);
+  EXPECT_EQ(status, Status::Ok());
   return status;
 }
 
@@ -34,45 +34,46 @@
   PW_TRY(ReturnStatusWithSize(status));
 
   // Any status other than OK should have already returned.
-  EXPECT_EQ(status.status(), Status::OK);
+  EXPECT_EQ(status.status(), Status::Ok());
   return status.status();
 }
 
 TEST(Status, Try_Status) {
-  EXPECT_EQ(TryStatus(Status::OK), Status::OK);
+  EXPECT_EQ(TryStatus(Status::Ok()), Status::Ok());
 
   // Don't need all the status types, just pick a few not-ok ones.
-  EXPECT_EQ(TryStatus(Status::CANCELLED), Status::CANCELLED);
-  EXPECT_EQ(TryStatus(Status::DATA_LOSS), Status::DATA_LOSS);
-  EXPECT_EQ(TryStatus(Status::UNIMPLEMENTED), Status::UNIMPLEMENTED);
+  EXPECT_EQ(TryStatus(Status::Cancelled()), Status::Cancelled());
+  EXPECT_EQ(TryStatus(Status::DataLoss()), Status::DataLoss());
+  EXPECT_EQ(TryStatus(Status::Unimplemented()), Status::Unimplemented());
 }
 
 TEST(Status, Try_StatusWithSizeOk) {
   for (size_t i = 0; i < 32; ++i) {
-    StatusWithSize val(Status::OK, 0);
-    EXPECT_EQ(TryStatus(val), Status::OK);
+    StatusWithSize val(Status::Ok(), 0);
+    EXPECT_EQ(TryStatus(val), Status::Ok());
   }
 }
 
 TEST(Status, Try_StatusWithSizeError) {
   for (size_t i = 0; i < 32; ++i) {
-    StatusWithSize val(Status::DATA_LOSS, i);
-    EXPECT_EQ(TryStatus(val), Status::DATA_LOSS);
+    StatusWithSize val(Status::DataLoss(), i);
+    EXPECT_EQ(TryStatus(val), Status::DataLoss());
   }
 }
 
 TEST(Status, Try_StatusWithSizeFromConstant) {
   // Don't need all the status types, just pick a few not-ok ones.
-  EXPECT_EQ(TryStatus(StatusWithSize::CANCELLED), Status::CANCELLED);
-  EXPECT_EQ(TryStatus(StatusWithSize::DATA_LOSS), Status::DATA_LOSS);
-  EXPECT_EQ(TryStatus(StatusWithSize::UNIMPLEMENTED), Status::UNIMPLEMENTED);
+  EXPECT_EQ(TryStatus(StatusWithSize::Cancelled()), Status::Cancelled());
+  EXPECT_EQ(TryStatus(StatusWithSize::DataLoss()), Status::DataLoss());
+  EXPECT_EQ(TryStatus(StatusWithSize::Unimplemented()),
+            Status::Unimplemented());
 }
 
 Status TryStatusAssign(size_t& size_val, StatusWithSize status) {
   PW_TRY_ASSIGN(size_val, ReturnStatusWithSize(status));
 
   // Any status other than OK should have already returned.
-  EXPECT_EQ(status.status(), Status::OK);
+  EXPECT_EQ(status.status(), Status::Ok());
   EXPECT_EQ(size_val, status.size());
   return status.status();
 }
@@ -81,8 +82,8 @@
   size_t size_val = 0;
 
   for (size_t i = 1; i < 32; ++i) {
-    StatusWithSize val(Status::OK, i);
-    EXPECT_EQ(TryStatusAssign(size_val, val), Status::OK);
+    StatusWithSize val(Status::Ok(), i);
+    EXPECT_EQ(TryStatusAssign(size_val, val), Status::Ok());
     EXPECT_EQ(size_val, i);
   }
 }
@@ -91,8 +92,8 @@
   size_t size_val = 0u;
 
   for (size_t i = 1; i < 32; ++i) {
-    StatusWithSize val(Status::OUT_OF_RANGE, i);
-    EXPECT_EQ(TryStatusAssign(size_val, val), Status::OUT_OF_RANGE);
+    StatusWithSize val(Status::OutOfRange(), i);
+    EXPECT_EQ(TryStatusAssign(size_val, val), Status::OutOfRange());
     EXPECT_EQ(size_val, 0u);
   }
 }
@@ -109,52 +110,52 @@
   PW_TRY_WITH_SIZE(ReturnStatus(status));
 
   // Any status other than OK should have already returned.
-  EXPECT_EQ(status, Status::OK);
+  EXPECT_EQ(status, Status::Ok());
 
   StatusWithSize return_val(status, 0u);
   return return_val;
 }
 
 TEST(Status, TryWithSize_StatusOk) {
-  StatusWithSize result = TryStatusWithSize(Status::OK);
-  EXPECT_EQ(result.status(), Status::OK);
+  StatusWithSize result = TryStatusWithSize(Status::Ok());
+  EXPECT_EQ(result.status(), Status::Ok());
   EXPECT_EQ(result.size(), 0u);
 }
 
 TEST(Status, TryWithSize_StatusError) {
-  StatusWithSize result = TryStatusWithSize(Status::PERMISSION_DENIED);
-  EXPECT_EQ(result.status(), Status::PERMISSION_DENIED);
+  StatusWithSize result = TryStatusWithSize(Status::PermissionDenied());
+  EXPECT_EQ(result.status(), Status::PermissionDenied());
   EXPECT_EQ(result.size(), 0u);
 }
 
 TEST(Status, TryWithSize_StatusWithSizeOk) {
   for (size_t i = 0; i < 32; ++i) {
-    StatusWithSize val(Status::OK, i);
-    EXPECT_EQ(TryStatusWithSize(val).status(), Status::OK);
+    StatusWithSize val(Status::Ok(), i);
+    EXPECT_EQ(TryStatusWithSize(val).status(), Status::Ok());
     EXPECT_EQ(TryStatusWithSize(val).size(), i);
   }
 }
 
 TEST(Status, TryWithSize_StatusWithSizeError) {
   for (size_t i = 0; i < 32; ++i) {
-    StatusWithSize val(Status::DATA_LOSS, i);
+    StatusWithSize val(Status::DataLoss(), i);
     StatusWithSize result = TryStatusWithSize(val);
-    EXPECT_EQ(result.status(), Status::DATA_LOSS);
+    EXPECT_EQ(result.status(), Status::DataLoss());
     EXPECT_EQ(result.size(), i);
   }
 }
 
 TEST(Status, TryWithSize_StatusWithSizeConst) {
-  StatusWithSize result = TryStatusWithSize(StatusWithSize::DATA_LOSS);
-  EXPECT_EQ(result.status(), Status::DATA_LOSS);
+  StatusWithSize result = TryStatusWithSize(StatusWithSize::DataLoss());
+  EXPECT_EQ(result.status(), Status::DataLoss());
   EXPECT_EQ(result.size(), 0u);
 
-  result = TryStatusWithSize(StatusWithSize::NOT_FOUND);
-  EXPECT_EQ(result.status(), Status::NOT_FOUND);
+  result = TryStatusWithSize(StatusWithSize::NotFound());
+  EXPECT_EQ(result.status(), Status::NotFound());
   EXPECT_EQ(result.size(), 0u);
 
-  result = TryStatusWithSize(StatusWithSize::UNIMPLEMENTED);
-  EXPECT_EQ(result.status(), Status::UNIMPLEMENTED);
+  result = TryStatusWithSize(StatusWithSize::Unimplemented());
+  EXPECT_EQ(result.status(), Status::Unimplemented());
   EXPECT_EQ(result.size(), 0u);
 }
 
diff --git a/pw_stream/memory_stream.cc b/pw_stream/memory_stream.cc
index b0a9c36..8f7e29e 100644
--- a/pw_stream/memory_stream.cc
+++ b/pw_stream/memory_stream.cc
@@ -23,22 +23,22 @@
 
 Status MemoryWriter::DoWrite(ConstByteSpan data) {
   if (ConservativeWriteLimit() == 0) {
-    return Status::OUT_OF_RANGE;
+    return Status::OutOfRange();
   }
   if (ConservativeWriteLimit() < data.size_bytes()) {
-    return Status::RESOURCE_EXHAUSTED;
+    return Status::ResourceExhausted();
   }
 
   size_t bytes_to_write = data.size_bytes();
   std::memcpy(dest_.data() + bytes_written_, data.data(), bytes_to_write);
   bytes_written_ += bytes_to_write;
 
-  return Status::OK;
+  return Status::Ok();
 }
 
 StatusWithSize MemoryReader::DoRead(ByteSpan dest) {
   if (source_.size_bytes() == bytes_read_) {
-    return StatusWithSize::OUT_OF_RANGE;
+    return StatusWithSize::OutOfRange();
   }
 
   size_t bytes_to_read =
diff --git a/pw_stream/memory_stream_test.cc b/pw_stream/memory_stream_test.cc
index e08a299..0a0241e 100644
--- a/pw_stream/memory_stream_test.cc
+++ b/pw_stream/memory_stream_test.cc
@@ -38,7 +38,7 @@
   EXPECT_EQ(memory_writer.bytes_written(), 0u);
   Status status =
       memory_writer.Write(&kExpectedStruct, sizeof(kExpectedStruct));
-  EXPECT_EQ(status, Status::OK);
+  EXPECT_EQ(status, Status::Ok());
   EXPECT_EQ(memory_writer.bytes_written(), sizeof(kExpectedStruct));
 }  // namespace
 
@@ -68,13 +68,14 @@
     for (size_t i = 0; i < sizeof(buffer); ++i) {
       buffer[i] = std::byte(counter++);
     }
-    EXPECT_EQ(memory_writer.Write(std::span(buffer)), Status::OK);
+    EXPECT_EQ(memory_writer.Write(std::span(buffer)), Status::Ok());
   }
 
   EXPECT_GT(memory_writer.ConservativeWriteLimit(), 0u);
   EXPECT_LT(memory_writer.ConservativeWriteLimit(), kTempBufferSize);
 
-  EXPECT_EQ(memory_writer.Write(std::span(buffer)), Status::RESOURCE_EXHAUSTED);
+  EXPECT_EQ(memory_writer.Write(std::span(buffer)),
+            Status::ResourceExhausted());
   EXPECT_EQ(memory_writer.bytes_written(), counter);
 
   counter = 0;
@@ -98,12 +99,12 @@
     size_t bytes_to_write =
         std::min(sizeof(buffer), memory_writer.ConservativeWriteLimit());
     EXPECT_EQ(memory_writer.Write(std::span(buffer, bytes_to_write)),
-              Status::OK);
+              Status::Ok());
   }
 
   EXPECT_EQ(memory_writer.ConservativeWriteLimit(), 0u);
 
-  EXPECT_EQ(memory_writer.Write(std::span(buffer)), Status::OUT_OF_RANGE);
+  EXPECT_EQ(memory_writer.Write(std::span(buffer)), Status::OutOfRange());
   EXPECT_EQ(memory_writer.bytes_written(), memory_buffer.size());
 
   for (const std::byte& value : memory_writer.WrittenData()) {
@@ -115,7 +116,7 @@
   std::byte buffer[5] = {};
 
   MemoryWriter memory_writer(memory_buffer);
-  EXPECT_EQ(memory_writer.Write(buffer, 0), Status::OK);
+  EXPECT_EQ(memory_writer.Write(buffer, 0), Status::Ok());
   EXPECT_EQ(memory_writer.bytes_written(), 0u);
 }
 
@@ -169,7 +170,7 @@
   // Read exactly the available bytes.
   EXPECT_EQ(memory_reader.ConservativeReadLimit(), dest.size());
   Result<ByteSpan> result = memory_reader.Read(dest);
-  EXPECT_EQ(result.status(), Status::OK);
+  EXPECT_EQ(result.status(), Status::Ok());
   EXPECT_EQ(result.value().size_bytes(), dest.size());
 
   ASSERT_EQ(source.size(), result.value().size_bytes());
@@ -180,7 +181,7 @@
   // Shoud be no byte remaining.
   EXPECT_EQ(memory_reader.ConservativeReadLimit(), 0u);
   result = memory_reader.Read(dest);
-  EXPECT_EQ(result.status(), Status::OUT_OF_RANGE);
+  EXPECT_EQ(result.status(), Status::OutOfRange());
 }
 
 TEST(MemoryReader, EmptySpanRead) {
@@ -195,7 +196,7 @@
 
   // Read exactly the available bytes.
   Result<ByteSpan> result = memory_reader.Read(dest);
-  EXPECT_EQ(result.status(), Status::OK);
+  EXPECT_EQ(result.status(), Status::Ok());
   EXPECT_EQ(result.value().size_bytes(), 0u);
   EXPECT_EQ(result.value().data(), dest.data());
 
@@ -218,7 +219,7 @@
   // Try and read double the bytes available. Use the pointer/size version of
   // the API.
   Result<ByteSpan> result = memory_reader.Read(dest.data(), dest.size());
-  EXPECT_EQ(result.status(), Status::OK);
+  EXPECT_EQ(result.status(), Status::Ok());
   EXPECT_EQ(result.value().size_bytes(), source.size());
 
   ASSERT_EQ(source.size(), result.value().size_bytes());
@@ -229,7 +230,7 @@
   // Shoud be no byte remaining.
   EXPECT_EQ(memory_reader.ConservativeReadLimit(), 0u);
   result = memory_reader.Read(dest);
-  EXPECT_EQ(result.status(), Status::OUT_OF_RANGE);
+  EXPECT_EQ(result.status(), Status::OutOfRange());
 }
 
 TEST(MemoryReader, MultipleReads) {
@@ -253,7 +254,7 @@
 
     // Try and read a chunk of bytes.
     Result<ByteSpan> result = memory_reader.Read(dest);
-    EXPECT_EQ(result.status(), Status::OK);
+    EXPECT_EQ(result.status(), Status::Ok());
     EXPECT_EQ(result.value().size_bytes(), dest.size());
     EXPECT_EQ(memory_reader.ConservativeReadLimit(),
               read_limit - result.value().size_bytes());
diff --git a/pw_stream/public/pw_stream/memory_stream.h b/pw_stream/public/pw_stream/memory_stream.h
index 980381a..299fb3a 100644
--- a/pw_stream/public/pw_stream/memory_stream.h
+++ b/pw_stream/public/pw_stream/memory_stream.h
@@ -41,7 +41,7 @@
   // Implementation for writing data to this stream.
   //
   // If the in-memory buffer is exhausted in the middle of a write, this will
-  // perform a partial write and Status::RESOURCE_EXHAUSTED will be returned.
+  // perform a partial write and Status::ResourceExhausted() will be returned.
   Status DoWrite(ConstByteSpan data) override;
 
   ByteSpan dest_;
diff --git a/pw_stream/public/pw_stream/null_stream.h b/pw_stream/public/pw_stream/null_stream.h
index b5482c3..70048dc 100644
--- a/pw_stream/public/pw_stream/null_stream.h
+++ b/pw_stream/public/pw_stream/null_stream.h
@@ -33,7 +33,7 @@
   }
 
  private:
-  Status DoWrite(ConstByteSpan data) override { return Status::OK; }
+  Status DoWrite(ConstByteSpan data) override { return Status::Ok(); }
 };
 
 }  // namespace pw::stream
diff --git a/pw_stream/public/pw_stream/stream.h b/pw_stream/public/pw_stream/stream.h
index 66a5955..5e0a0c0 100644
--- a/pw_stream/public/pw_stream/stream.h
+++ b/pw_stream/public/pw_stream/stream.h
@@ -73,7 +73,8 @@
   // written. This number is advisory and not guaranteed to write without a
   // RESOURCE_EXHAUSTED or OUT_OF_RANGE. As Writer processes/handles enqueued of
   // other contexts write data this number can go up or down for some Writers.
-  // Returns zero if, in the current state, Write() would not return Status::OK.
+  // Returns zero if, in the current state, Write() would not return
+  // Status::Ok().
   virtual size_t ConservativeWriteLimit() const = 0;
 
  private:
@@ -125,7 +126,8 @@
   // requested bytes or without a RESOURCE_EXHAUSTED or OUT_OF_RANGE. As Reader
   // processes/handles/receives enqueued data or other contexts read data this
   // number can go up or down for some Readers.
-  // Returns zero if, in the current state, Read() would not return Status::OK.
+  // Returns zero if, in the current state, Read() would not return
+  // Status::Ok().
   virtual size_t ConservativeReadLimit() const = 0;
 
  private:
diff --git a/pw_string/format.cc b/pw_string/format.cc
index c9ed379..c08bf3c 100644
--- a/pw_string/format.cc
+++ b/pw_string/format.cc
@@ -31,7 +31,7 @@
                             const char* format,
                             va_list args) {
   if (buffer.empty()) {
-    return StatusWithSize::RESOURCE_EXHAUSTED;
+    return StatusWithSize::ResourceExhausted();
   }
 
   const int result = std::vsnprintf(buffer.data(), buffer.size(), format, args);
@@ -40,12 +40,12 @@
   // Discard any output by terminating the buffer.
   if (result < 0) {
     buffer[0] = '\0';
-    return StatusWithSize::INVALID_ARGUMENT;
+    return StatusWithSize::InvalidArgument();
   }
 
   // If result >= buffer.size(), the output was truncated and null-terminated.
   if (static_cast<unsigned>(result) >= buffer.size()) {
-    return StatusWithSize(Status::RESOURCE_EXHAUSTED, buffer.size() - 1);
+    return StatusWithSize::ResourceExhausted(buffer.size() - 1);
   }
 
   return StatusWithSize(result);
diff --git a/pw_string/format_test.cc b/pw_string/format_test.cc
index dfaac7b..b7aab52 100644
--- a/pw_string/format_test.cc
+++ b/pw_string/format_test.cc
@@ -26,7 +26,7 @@
   char buffer[32];
   auto result = Format(buffer, "-_-");
 
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(3u, result.size());
   EXPECT_STREQ("-_-", buffer);
 }
@@ -35,7 +35,7 @@
   char buffer[32];
   auto result = Format(buffer, "%d4%s", 123, "5");
 
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(5u, result.size());
   EXPECT_STREQ("12345", buffer);
 }
@@ -43,7 +43,7 @@
 TEST(Format, EmptyBuffer_ReturnsResourceExhausted) {
   auto result = Format(std::span<char>(), "?");
 
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
+  EXPECT_EQ(Status::ResourceExhausted(), result.status());
   EXPECT_EQ(0u, result.size());
 }
 
@@ -51,7 +51,7 @@
   char buffer[5];
   auto result = Format(buffer, "2big!");
 
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
+  EXPECT_EQ(Status::ResourceExhausted(), result.status());
   EXPECT_EQ(4u, result.size());
   EXPECT_STREQ("2big", buffer);
 }
@@ -60,7 +60,7 @@
   char buffer[5];
   auto result = Format(buffer, "%s", "2big!");
 
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
+  EXPECT_EQ(Status::ResourceExhausted(), result.status());
   EXPECT_EQ(4u, result.size());
   EXPECT_STREQ("2big", buffer);
 }
@@ -81,7 +81,7 @@
   char buffer[8];
   auto result = CallFormatWithVaList(buffer, "Yo%s", "?!");
 
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_EQ(4u, result.size());
   EXPECT_STREQ("Yo?!", buffer);
 }
diff --git a/pw_string/public/pw_string/format.h b/pw_string/public/pw_string/format.h
index 5c0adfe..f3aa337 100644
--- a/pw_string/public/pw_string/format.h
+++ b/pw_string/public/pw_string/format.h
@@ -35,9 +35,9 @@
 //
 // The status is
 //
-//   Status::OK if the operation succeeded,
-//   Status::RESOURCE_EXHAUSTED if the buffer was too small to fit the output,
-//   Status::INVALID_ARGUMENT if there was a formatting error.
+//   Status::Ok() if the operation succeeded,
+//   Status::ResourceExhausted() if the buffer was too small to fit the output,
+//   Status::InvalidArgument() if there was a formatting error.
 //
 PW_PRINTF_FORMAT(2, 3)
 StatusWithSize Format(std::span<char> buffer, const char* format, ...);
diff --git a/pw_string/public/pw_string/string_builder.h b/pw_string/public/pw_string/string_builder.h
index 21769b3..425fbfb 100644
--- a/pw_string/public/pw_string/string_builder.h
+++ b/pw_string/public/pw_string/string_builder.h
@@ -135,7 +135,7 @@
   // The status from the last operation. May be OK while status() is not OK.
   Status last_status() const { return last_status_; }
 
-  // True if status() is Status::OK.
+  // True if status() is Status::Ok().
   bool ok() const { return status_.ok(); }
 
   // True if the string is empty.
@@ -150,10 +150,10 @@
   // Clears the string and resets its error state.
   void clear();
 
-  // Sets the statuses to Status::OK;
+  // Sets the statuses to Status::Ok();
   void clear_status() {
-    status_ = Status::OK;
-    last_status_ = Status::OK;
+    status_ = Status::Ok();
+    last_status_ = Status::Ok();
   }
 
   // Appends a single character. Stets the status to RESOURCE_EXHAUSTED if the
diff --git a/pw_string/string_builder.cc b/pw_string/string_builder.cc
index b433e7f..1bc3b1f 100644
--- a/pw_string/string_builder.cc
+++ b/pw_string/string_builder.cc
@@ -24,8 +24,8 @@
 void StringBuilder::clear() {
   size_ = 0;
   NullTerminate();
-  status_ = Status::OK;
-  last_status_ = Status::OK;
+  status_ = Status::Ok();
+  last_status_ = Status::Ok();
 }
 
 StringBuilder& StringBuilder::append(size_t count, char ch) {
@@ -55,7 +55,7 @@
                                      size_t pos,
                                      size_t count) {
   if (pos > str.size()) {
-    SetErrorStatus(Status::OUT_OF_RANGE);
+    SetErrorStatus(Status::OutOfRange());
     return *this;
   }
 
@@ -68,9 +68,9 @@
   NullTerminate();
 
   if (buffer_.empty() || chars_to_append != copied) {
-    SetErrorStatus(Status::RESOURCE_EXHAUSTED);
+    SetErrorStatus(Status::ResourceExhausted());
   } else {
-    last_status_ = Status::OK;
+    last_status_ = Status::Ok();
   }
   return copied;
 }
@@ -79,9 +79,9 @@
   if (new_size <= size_) {
     size_ = new_size;
     NullTerminate();
-    last_status_ = Status::OK;
+    last_status_ = Status::Ok();
   } else {
-    SetErrorStatus(Status::OUT_OF_RANGE);
+    SetErrorStatus(Status::OutOfRange());
   }
 }
 
diff --git a/pw_string/string_builder_test.cc b/pw_string/string_builder_test.cc
index d078299..cfef0e7 100644
--- a/pw_string/string_builder_test.cc
+++ b/pw_string/string_builder_test.cc
@@ -75,7 +75,7 @@
   StringBuilder sb(std::span(buffer, 0));
 
   sb << CustomType() << " is " << 12345;
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.status());
   EXPECT_EQ(kNoTouch, std::string_view(buffer, sizeof(buffer)));
 }
 
@@ -102,44 +102,44 @@
 
 TEST(StringBuilder, EmptyBuffer_AppendEmpty_ResourceExhausted) {
   StringBuilder sb(std::span<char>{});
-  EXPECT_EQ(Status::OK, sb.last_status());
-  EXPECT_EQ(Status::OK, sb.status());
+  EXPECT_EQ(Status::Ok(), sb.last_status());
+  EXPECT_EQ(Status::Ok(), sb.status());
 
   sb << "";
 
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.last_status());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.last_status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.status());
 }
 
 TEST(StringBuilder, Status_StartsOk) {
   StringBuffer<16> sb;
-  EXPECT_EQ(Status::OK, sb.status());
-  EXPECT_EQ(Status::OK, sb.last_status());
+  EXPECT_EQ(Status::Ok(), sb.status());
+  EXPECT_EQ(Status::Ok(), sb.last_status());
 }
 
 TEST(StringBuilder, Status_StatusAndLastStatusUpdate) {
   StringBuffer<16> sb;
   sb << "Well, if only there were enough room in here for this string";
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.last_status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.last_status());
 
   sb.resize(1029);
-  EXPECT_EQ(Status::OUT_OF_RANGE, sb.status());
-  EXPECT_EQ(Status::OUT_OF_RANGE, sb.last_status());
+  EXPECT_EQ(Status::OutOfRange(), sb.status());
+  EXPECT_EQ(Status::OutOfRange(), sb.last_status());
 
   sb << "";
-  EXPECT_EQ(Status::OUT_OF_RANGE, sb.status());
-  EXPECT_EQ(Status::OK, sb.last_status());
+  EXPECT_EQ(Status::OutOfRange(), sb.status());
+  EXPECT_EQ(Status::Ok(), sb.last_status());
 }
 
 TEST(StringBuilder, Status_ClearStatus_SetsStatuesToOk) {
   StringBuffer<2> sb = MakeString<2>("Won't fit!!!!!");
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.last_status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.last_status());
 
   sb.clear_status();
-  EXPECT_EQ(Status::OK, sb.status());
-  EXPECT_EQ(Status::OK, sb.last_status());
+  EXPECT_EQ(Status::Ok(), sb.status());
+  EXPECT_EQ(Status::Ok(), sb.last_status());
 }
 
 TEST(StringBuilder, StreamOutput_OutputSelf) {
@@ -153,7 +153,7 @@
 TEST(StringBuilder, PushBack) {
   StringBuffer<12> sb;
   sb.push_back('?');
-  EXPECT_EQ(Status::OK, sb.last_status());
+  EXPECT_EQ(Status::Ok(), sb.last_status());
   EXPECT_EQ(1u, sb.size());
   EXPECT_STREQ("?", sb.data());
 }
@@ -161,14 +161,14 @@
 TEST(StringBuilder, PushBack_Full) {
   StringBuffer<1> sb;
   sb.push_back('!');
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.last_status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.last_status());
   EXPECT_EQ(0u, sb.size());
 }
 
 TEST(StringBuilder, PopBack) {
   auto sb = MakeString<12>("Welcome!");
   sb.pop_back();
-  EXPECT_EQ(Status::OK, sb.last_status());
+  EXPECT_EQ(Status::Ok(), sb.last_status());
   EXPECT_EQ(7u, sb.size());
   EXPECT_STREQ("Welcome", sb.data());
 }
@@ -176,7 +176,7 @@
 TEST(StringBuilder, PopBack_Empty) {
   StringBuffer<12> sb;
   sb.pop_back();
-  EXPECT_EQ(Status::OUT_OF_RANGE, sb.last_status());
+  EXPECT_EQ(Status::OutOfRange(), sb.last_status());
   EXPECT_EQ(0u, sb.size());
 }
 
@@ -185,7 +185,7 @@
   std::memset(bad_string, '?', sizeof(bad_string));
 
   StringBuffer<6> sb;
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.append(bad_string).last_status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.append(bad_string).last_status());
   EXPECT_STREQ("?????", sb.data());
 }
 
@@ -199,7 +199,7 @@
 TEST(StringBuilder, Append_Chars_Full) {
   StringBuffer<8> sb;
 
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.append(8, '?').last_status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.append(8, '?').last_status());
   EXPECT_STREQ("???????", sb.data());
 }
 
@@ -219,8 +219,8 @@
 
 TEST(StringBuilder, Append_CString_Full) {
   auto sb = MakeString<6>("hello");
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.append("890123", 1).last_status());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.append("890123", 1).last_status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.status());
   EXPECT_EQ(sb.max_size(), sb.size());
   EXPECT_STREQ("hello", sb.data());
 }
@@ -263,14 +263,14 @@
   auto sb = MakeString<12>("Four");
   EXPECT_EQ(4u, sb.size());
   sb.resize(10);
-  EXPECT_EQ(sb.status(), Status::OUT_OF_RANGE);
+  EXPECT_EQ(sb.status(), Status::OutOfRange());
   EXPECT_EQ(4u, sb.size());
 }
 
 TEST(StringBuilder, Resize_LargerThanCapacity_Fails) {
   auto sb = MakeString<12>("Four");
   sb.resize(1234);
-  EXPECT_EQ(sb.status(), Status::OUT_OF_RANGE);
+  EXPECT_EQ(sb.status(), Status::OutOfRange());
   EXPECT_EQ(4u, sb.size());
   EXPECT_STREQ("Four", sb.data());
 }
@@ -289,10 +289,10 @@
 
 TEST(StringBuilder, Format_ExhaustBuffer) {
   StringBuffer<6> sb;
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.Format("012345").status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.Format("012345").status());
 
   EXPECT_STREQ("01234", sb.data());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.status());
 }
 
 TEST(StringBuilder, StreamOutput_MultipleTypes) {
@@ -316,7 +316,7 @@
 
   sb << true << "Now it's way " << static_cast<unsigned char>(2) << " long";
   EXPECT_FALSE(sb.ok());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.status());
   EXPECT_STREQ("0true", sb.data());
 }
 
@@ -342,7 +342,7 @@
   EXPECT_EQ(2u, sb.size());
   sb << "234";
   EXPECT_STREQ("012", sb.data());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.status());
   EXPECT_EQ(3u, sb.size());
 }
 
@@ -353,7 +353,7 @@
   StringBuffer<6> sb;
   sb << "hey" << bad_string;
 
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.status());
   EXPECT_STREQ("hey??", sb.data());
 }
 
@@ -362,7 +362,7 @@
   constexpr std::string_view hello("hello");
 
   buffer << hello;
-  EXPECT_EQ(Status::OK, buffer.status());
+  EXPECT_EQ(Status::Ok(), buffer.status());
   EXPECT_STREQ("hello", buffer.data());
 }
 
@@ -390,13 +390,13 @@
 
   two << "0123456789";
   ASSERT_STREQ("What heck", two.data());
-  ASSERT_EQ(Status::RESOURCE_EXHAUSTED, two.status());
-  ASSERT_EQ(Status::RESOURCE_EXHAUSTED, two.last_status());
+  ASSERT_EQ(Status::ResourceExhausted(), two.status());
+  ASSERT_EQ(Status::ResourceExhausted(), two.last_status());
 
   one = two;
   EXPECT_STREQ("What heck", one.data());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, one.status());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, one.last_status());
+  EXPECT_EQ(Status::ResourceExhausted(), one.status());
+  EXPECT_EQ(Status::ResourceExhausted(), one.last_status());
 
   StringBuffer<12> three;
   three = two;
@@ -421,8 +421,8 @@
   two << "0123456789";
   two << "";
   ASSERT_STREQ("What heck", two.data());
-  ASSERT_EQ(Status::RESOURCE_EXHAUSTED, two.status());
-  ASSERT_EQ(Status::OK, two.last_status());
+  ASSERT_EQ(Status::ResourceExhausted(), two.status());
+  ASSERT_EQ(Status::Ok(), two.last_status());
 }
 
 TEST(StringBuffer, CopyConstructFromSmaller) {
@@ -430,7 +430,7 @@
   StringBuffer<12> two(one);
 
   EXPECT_STREQ("You are t", two.data());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, two.status());
+  EXPECT_EQ(Status::ResourceExhausted(), two.status());
 }
 
 TEST(StringBuilder, Object) {
@@ -514,7 +514,7 @@
 TEST(MakeString, LargerThanDefaultSize_Truncates) {
   auto sb = MakeString("1844674407", 3709551615, 123456);
 
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
+  EXPECT_EQ(Status::ResourceExhausted(), sb.status());
   EXPECT_STREQ(kLongestString, sb.data());
 }
 
diff --git a/pw_string/to_string_test.cc b/pw_string/to_string_test.cc
index 6f4a4da..2f3608d 100644
--- a/pw_string/to_string_test.cc
+++ b/pw_string/to_string_test.cc
@@ -43,13 +43,13 @@
   int result =
       std::snprintf(buffer.data(), buffer.size(), CustomType::kToString);
   if (result < 0) {
-    return StatusWithSize::UNKNOWN;
+    return StatusWithSize::Unknown();
   }
   if (static_cast<size_t>(result) < buffer.size()) {
     return StatusWithSize(result);
   }
-  return StatusWithSize(Status::RESOURCE_EXHAUSTED,
-                        buffer.empty() ? 0u : buffer.size() - 1);
+  return StatusWithSize::ResourceExhausted(buffer.empty() ? 0u
+                                                          : buffer.size() - 1);
 }
 
 namespace {
@@ -101,14 +101,14 @@
 
   auto result = ToString(MyEnum::kLuckyNumber, buffer);
   EXPECT_EQ(1u, result.size());
-  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(Status::Ok(), result.status());
   EXPECT_STREQ("8", buffer);
 }
 
 TEST(ToString, Integer_EmptyBuffer_WritesNothing) {
   auto result = ToString(-1234, std::span(buffer, 0));
   EXPECT_EQ(0u, result.size());
-  EXPECT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
+  EXPECT_EQ(Status::ResourceExhausted(), result.status());
 }
 
 TEST(ToString, Integer_BufferTooSmall_WritesNullTerminator) {
@@ -218,7 +218,7 @@
 
 TEST(ToString, StatusCode) {
   EXPECT_EQ(sizeof("UNAVAILABLE") - 1,
-            ToString(Status::UNAVAILABLE, buffer).size());
+            ToString(Status::Unavailable(), buffer).size());
   EXPECT_STREQ("UNAVAILABLE", buffer);
 }
 
diff --git a/pw_string/type_to_string.cc b/pw_string/type_to_string.cc
index ce417e1..483d10e 100644
--- a/pw_string/type_to_string.cc
+++ b/pw_string/type_to_string.cc
@@ -51,7 +51,7 @@
   if (!buffer.empty()) {
     buffer[0] = '\0';
   }
-  return StatusWithSize::RESOURCE_EXHAUSTED;
+  return StatusWithSize::ResourceExhausted();
 }
 
 }  // namespace
@@ -183,14 +183,15 @@
 StatusWithSize CopyString(const std::string_view& value,
                           std::span<char> buffer) {
   if (buffer.empty()) {
-    return StatusWithSize::RESOURCE_EXHAUSTED;
+    return StatusWithSize::ResourceExhausted();
   }
 
   const size_t copied = value.copy(buffer.data(), buffer.size() - 1);
   buffer[copied] = '\0';
 
   return StatusWithSize(
-      copied == value.size() ? Status::OK : Status::RESOURCE_EXHAUSTED, copied);
+      copied == value.size() ? Status::Ok() : Status::ResourceExhausted(),
+      copied);
 }
 
 StatusWithSize CopyEntireString(const std::string_view& value,
diff --git a/pw_sys_io/public/pw_sys_io/sys_io.h b/pw_sys_io/public/pw_sys_io/sys_io.h
index 5f545b3..5973579 100644
--- a/pw_sys_io/public/pw_sys_io/sys_io.h
+++ b/pw_sys_io/public/pw_sys_io/sys_io.h
@@ -20,7 +20,7 @@
 //
 // This facade doesn't dictate any policies on input and output data encoding,
 // format, or transmission protocol. It only requires that backends return a
-// Status::OK if the operation succeeds. Backends may provide useful error
+// Status::Ok() if the operation succeeds. Backends may provide useful error
 // Status types, but depending on the implementation-specific Status values is
 // NOT recommended. Since this facade provides a very vague I/O interface, it
 // does NOT provide tests. Backends are expected to provide their own testing to
@@ -51,7 +51,7 @@
 // This function will block until it either succeeds or fails to read a byte
 // from the pw_sys_io backend.
 //
-// Returns Status::OK if a byte was successfully read.
+// Returns Status::Ok() if a byte was successfully read.
 Status ReadByte(std::byte* dest);
 
 // Write a single byte out the sys io backend.
@@ -60,7 +60,7 @@
 // This function will block until it either succeeds or fails to write a byte
 // out the pw_sys_io backend.
 //
-// Returns Status::OK if a byte was successfully read.
+// Returns Status::Ok() if a byte was successfully read.
 Status WriteByte(std::byte b);
 
 // Write a string out the sys io backend.
@@ -70,7 +70,7 @@
 // backend, adding any platform-specific newline character(s) (these are
 // accounted for in the returned StatusWithSize).
 //
-// Return status is Status::OK if all the bytes from the source string were
+// Return status is Status::Ok() if all the bytes from the source string were
 // successfully written. In all cases, the number of bytes successfully written
 // are returned as part of the StatusWithSize.
 StatusWithSize WriteLine(const std::string_view& s);
@@ -84,9 +84,9 @@
 // undefined. This function blocks until either an error occurs, or all bytes
 // are successfully read from the backend's ReadByte() implementation.
 //
-// Return status is Status::OK if the destination span was successfully filled.
-// In all cases, the number of bytes successuflly read to the destination span
-// are returned as part of the StatusWithSize.
+// Return status is Status::Ok() if the destination span was successfully
+// filled. In all cases, the number of bytes successuflly read to the
+// destination span are returned as part of the StatusWithSize.
 StatusWithSize ReadBytes(std::span<std::byte> dest);
 
 // Write std::span of bytes out the sys io backend using WriteByte().
@@ -98,7 +98,7 @@
 // either an error occurs, or all bytes are successfully read from the backend's
 // WriteByte() implementation.
 //
-// Return status is Status::OK if all the bytes from the source span were
+// Return status is Status::Ok() if all the bytes from the source span were
 // successfully written. In all cases, the number of bytes successfully written
 // are returned as part of the StatusWithSize.
 StatusWithSize WriteBytes(std::span<const std::byte> src);
diff --git a/pw_sys_io_arduino/sys_io_arduino.cc b/pw_sys_io_arduino/sys_io_arduino.cc
index b63e21f..c06f3a9 100644
--- a/pw_sys_io_arduino/sys_io_arduino.cc
+++ b/pw_sys_io_arduino/sys_io_arduino.cc
@@ -40,7 +40,7 @@
       break;
     }
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 // Send a byte over USART1. Since this blocks on every byte, it's rather
@@ -53,7 +53,7 @@
   while (Serial.availableForWrite() < 1) {
   }
   Serial.write((uint8_t)b);
-  return Status::OK;
+  return Status::Ok();
 }
 
 // Writes a string using pw::sys_io, and add newline characters at the end.
diff --git a/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc b/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc
index 253b0c5..ddf901e 100644
--- a/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc
+++ b/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc
@@ -99,7 +99,7 @@
       break;
     }
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 // Send a byte over UART0. Since this blocks on every byte, it's rather
@@ -112,7 +112,7 @@
   while (!(uart0.status_flags & kTxFifoEmptyMask)) {
   }
   uart0.data_register = static_cast<uint32_t>(b);
-  return Status::OK;
+  return Status::Ok();
 }
 
 // Writes a string using pw::sys_io, and add newline characters at the end.
diff --git a/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc b/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc
index 46f5e40..80cb169 100644
--- a/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc
+++ b/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc
@@ -175,7 +175,7 @@
       break;
     }
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 // Send a byte over USART1. Since this blocks on every byte, it's rather
@@ -188,7 +188,7 @@
   while (!(usart1.status & kTxRegisterEmpty)) {
   }
   usart1.data_register = static_cast<uint32_t>(b);
-  return Status::OK;
+  return Status::Ok();
 }
 
 // Writes a string using pw::sys_io, and add newline characters at the end.
diff --git a/pw_sys_io_stdio/sys_io.cc b/pw_sys_io_stdio/sys_io.cc
index 65d1a89..04ab9b0 100644
--- a/pw_sys_io_stdio/sys_io.cc
+++ b/pw_sys_io_stdio/sys_io.cc
@@ -20,22 +20,22 @@
 
 Status ReadByte(std::byte* dest) {
   if (dest == nullptr) {
-    return Status::FAILED_PRECONDITION;
+    return Status::FailedPrecondition();
   }
 
   int value = std::getchar();
   if (value == EOF) {
-    return Status::RESOURCE_EXHAUSTED;
+    return Status::ResourceExhausted();
   }
   *dest = static_cast<std::byte>(value);
-  return Status::OK;
+  return Status::Ok();
 }
 
 Status WriteByte(std::byte b) {
   if (std::putchar(static_cast<char>(b)) == EOF) {
-    return Status::INTERNAL;
+    return Status::Internal();
   }
-  return Status::OK;
+  return Status::Ok();
 }
 
 StatusWithSize WriteLine(const std::string_view& s) {
diff --git a/pw_trace_tokenized/public/pw_trace_tokenized/trace_callback.h b/pw_trace_tokenized/public/pw_trace_tokenized/trace_callback.h
index bfa3d8b..ab6e8e6 100644
--- a/pw_trace_tokenized/public/pw_trace_tokenized/trace_callback.h
+++ b/pw_trace_tokenized/public/pw_trace_tokenized/trace_callback.h
@@ -101,7 +101,7 @@
 // start, allowing buffers to allocate the required amount at the start when
 // necessary.
 //
-// If Status::OK is not returned from Start, the events bytes will be skipped.
+// If Status::Ok() is not returned from Start, the events bytes will be skipped.
 //
 // NOTE: Called while tracing is locked (which might be a critical section
 // depending on application), so quick/simple operations only. One trace event
diff --git a/pw_trace_tokenized/trace_buffer_log.cc b/pw_trace_tokenized/trace_buffer_log.cc
index 3e41c3a..3d9e5a6 100644
--- a/pw_trace_tokenized/trace_buffer_log.cc
+++ b/pw_trace_tokenized/trace_buffer_log.cc
@@ -54,7 +54,7 @@
   size_t bytes_read = 0;
   PW_LOG_INFO("[TRACE] begin");
   while (trace_buffer->PeekFront(std::span(entry_buffer).subspan(1),
-                                 &bytes_read) != pw::Status::OUT_OF_RANGE) {
+                                 &bytes_read) != pw::Status::OutOfRange()) {
     trace_buffer->PopFront();
     entry_buffer[0] = static_cast<std::byte>(bytes_read);
     // The entry buffer is formatted as (size, entry) with an extra byte as
@@ -78,7 +78,7 @@
     PW_LOG_INFO("[TRACE] data: %s", line_builder.c_str());
   }
   PW_LOG_INFO("[TRACE] end");
-  return pw::Status::OK;
+  return pw::Status::Ok();
 }
 
 }  // namespace trace
diff --git a/pw_trace_tokenized/trace_buffer_test.cc b/pw_trace_tokenized/trace_buffer_test.cc
index 0133c9e..bbe7dc8 100644
--- a/pw_trace_tokenized/trace_buffer_test.cc
+++ b/pw_trace_tokenized/trace_buffer_test.cc
@@ -84,7 +84,7 @@
   std::byte value[expected_max_bytes_used];
   size_t bytes_read = 0;
   EXPECT_EQ(buf->PeekFront(std::span<std::byte>(value), &bytes_read),
-            pw::Status::OK);
+            pw::Status::Ok());
 
   // read size is minus 1, since doesn't include varint size
   EXPECT_GE(bytes_read, expected_min_bytes_used - 1);
@@ -123,8 +123,8 @@
     std::byte value[PW_TRACE_BUFFER_MAX_BLOCK_SIZE_BYTES];
     size_t bytes_read = 0;
     EXPECT_EQ(buf->PeekFront(std::span<std::byte>(value), &bytes_read),
-              pw::Status::OK);
-    EXPECT_EQ(buf->PopFront(), pw::Status::OK);
+              pw::Status::Ok());
+    EXPECT_EQ(buf->PopFront(), pw::Status::Ok());
     EXPECT_EQ(*reinterpret_cast<size_t*>(&value[bytes_read - sizeof(size_t)]),
               expected_count);
     expected_count++;
diff --git a/pw_varint/public/pw_varint/varint.h b/pw_varint/public/pw_varint/varint.h
index 9935967..a8db949 100644
--- a/pw_varint/public/pw_varint/varint.h
+++ b/pw_varint/public/pw_varint/varint.h
@@ -119,7 +119,7 @@
 //     size_t bytes = Decode(data, &value);
 //
 //     if (bytes == 0u) {
-//       return Status::DATA_LOSS;
+//       return Status::DataLoss();
 //     }
 //     results.push_back(value);
 //     data = data.subspan(bytes)