diff --git a/pw_log_tokenized/docs.rst b/pw_log_tokenized/docs.rst
index 4632af6..1225006 100644
--- a/pw_log_tokenized/docs.rst
+++ b/pw_log_tokenized/docs.rst
@@ -9,7 +9,7 @@
 ----------------
 ``pw_log_tokenized`` is a ``pw_log`` backend that tokenizes log messages using
 the ``pw_tokenizer`` module. Log messages are tokenized and passed to the
-``pw_TokenizerHandleEncodedMessageWithPayload`` function. For maximum
+``pw_tokenizer_HandleEncodedMessageWithPayload`` function. For maximum
 efficiency, the log level, 16-bit tokenized module name, and flags bits are
 passed through the payload argument.
 
@@ -17,8 +17,8 @@
 
 .. code-block:: cpp
 
-   extern "C" void pw_TokenizerHandleEncodedMessageWithPayload(
-       pw_TokenizerPayload payload, const uint8_t message[], size_t size) {
+   extern "C" void pw_tokenizer_HandleEncodedMessageWithPayload(
+       pw_tokenizer_Payload payload, const uint8_t message[], size_t size) {
      // The metadata object provides the log level, module token, and flags.
      // These values can be recorded and used for runtime filtering.
      pw::log_tokenized::Metadata metadata(payload);
diff --git a/pw_log_tokenized/public/pw_log_tokenized/log_tokenized.h b/pw_log_tokenized/public/pw_log_tokenized/log_tokenized.h
index 59d48d0..1589e88 100644
--- a/pw_log_tokenized/public/pw_log_tokenized/log_tokenized.h
+++ b/pw_log_tokenized/public/pw_log_tokenized/log_tokenized.h
@@ -24,12 +24,12 @@
 // PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD. The log level, module token, and
 // flags are packed into the payload argument.
 //
-// To use this macro, implement pw_TokenizerHandleEncodedMessageWithPayload,
+// To use this macro, implement pw_tokenizer_HandleEncodedMessageWithPayload,
 // which is defined in pw_tokenizer/tokenize.h. The log metadata can be accessed
 // using pw::log_tokenized::Metadata. For example:
 //
-//   extern "C" void pw_TokenizerHandleEncodedMessageWithPayload(
-//       pw_TokenizerPayload payload, const uint8_t data[], size_t size) {
+//   extern "C" void pw_tokenizer_HandleEncodedMessageWithPayload(
+//       pw_tokenizer_Payload payload, const uint8_t data[], size_t size) {
 //     pw::log_tokenized::Metadata metadata(payload);
 //
 //     if (metadata.level() >= kLogLevel && ModuleEnabled(metadata.module())) {
diff --git a/pw_log_tokenized/test.cc b/pw_log_tokenized/test.cc
index 7355839..6b5f976 100644
--- a/pw_log_tokenized/test.cc
+++ b/pw_log_tokenized/test.cc
@@ -26,14 +26,12 @@
 Metadata metadata(0);
 size_t encoded_data_size = 0;
 
-extern "C" void pw_TokenizerHandleEncodedMessageWithPayload(
-    pw_TokenizerPayload payload, const uint8_t[], size_t size) {
+extern "C" void pw_tokenizer_HandleEncodedMessageWithPayload(
+    pw_tokenizer_Payload payload, const uint8_t[], size_t size) {
   metadata = payload;
   encoded_data_size = size;
 }
 
-extern "C" void pw_TokenizerHandleEncodedMessage(const uint8_t[], size_t) {}
-
 constexpr uintptr_t kModuleToken =
     PW_TOKENIZER_STRING_TOKEN(PW_LOG_MODULE_NAME) &
     ((1u << _PW_LOG_TOKENIZED_MODULE_BITS) - 1);
diff --git a/pw_metric/public/pw_metric/metric.h b/pw_metric/public/pw_metric/metric.h
index 9c45ea0..89873e9 100644
--- a/pw_metric/public/pw_metric/metric.h
+++ b/pw_metric/public/pw_metric/metric.h
@@ -26,7 +26,7 @@
 
 // Currently, this is for tokens, but later may be a char* when non-tokenized
 // metric names are supported.
-typedef uint32_t Token;
+using tokenizer::Token;
 
 // An individual metric. There are only two supported types: uint32_t and
 // float. More complicated compound metrics can be built on these primitives.
diff --git a/pw_tokenizer/argument_types_test_c.c b/pw_tokenizer/argument_types_test_c.c
index f594200..2030587 100644
--- a/pw_tokenizer/argument_types_test_c.c
+++ b/pw_tokenizer/argument_types_test_c.c
@@ -72,10 +72,10 @@
 static char char_array[16];
 
 // Define the test functions that are called by the C++ unit test.
-#define DEFINE_TEST_FUNCTION(name, ...)               \
-  pw_TokenizerArgTypes pw_TestTokenizer##name(void) { \
-    (void)char_array;                                 \
-    return PW_TOKENIZER_ARG_TYPES(__VA_ARGS__);       \
+#define DEFINE_TEST_FUNCTION(name, ...)                 \
+  _pw_tokenizer_ArgTypes pw_TestTokenizer##name(void) { \
+    (void)char_array;                                   \
+    return PW_TOKENIZER_ARG_TYPES(__VA_ARGS__);         \
   }
 
 DEFINE_TEST_FUNCTION(NoArgs);
diff --git a/pw_tokenizer/base64.cc b/pw_tokenizer/base64.cc
index 6ce4a4c..3404916 100644
--- a/pw_tokenizer/base64.cc
+++ b/pw_tokenizer/base64.cc
@@ -20,7 +20,7 @@
 
 namespace pw::tokenizer {
 
-extern "C" size_t pw_TokenizerPrefixedBase64Encode(
+extern "C" size_t pw_tokenizer_PrefixedBase64Encode(
     const void* binary_message,
     size_t binary_size_bytes,
     void* output_buffer,
@@ -41,10 +41,10 @@
   return encoded_size;
 }
 
-extern "C" size_t pw_TokenizerPrefixedBase64Decode(const void* base64_message,
-                                                   size_t base64_size_bytes,
-                                                   void* output_buffer,
-                                                   size_t output_buffer_size) {
+extern "C" size_t pw_tokenizer_PrefixedBase64Decode(const void* base64_message,
+                                                    size_t base64_size_bytes,
+                                                    void* output_buffer,
+                                                    size_t output_buffer_size) {
   const char* base64 = static_cast<const char*>(base64_message);
 
   if (base64_size_bytes == 0 || base64[0] != kBase64Prefix) {
diff --git a/pw_tokenizer/docs.rst b/pw_tokenizer/docs.rst
index f9f8536..2d6ffe4 100644
--- a/pw_tokenizer/docs.rst
+++ b/pw_tokenizer/docs.rst
@@ -165,15 +165,15 @@
 ``PW_TOKENIZER_CFG_ENCODING_BUFFER_SIZE_BYTES``.
 
 This macro is provided by the ``pw_tokenizer:global_handler`` facade. The
-backend for this facade must define the ``pw_TokenizerHandleEncodedMessage``
+backend for this facade must define the ``pw_tokenizer_HandleEncodedMessage``
 C-linkage function.
 
 .. code-block:: cpp
 
   PW_TOKENIZE_TO_GLOBAL_HANDLER(format_string_literal, arguments...);
 
-  void pw_TokenizerHandleEncodedMessage(const uint8_t encoded_message[],
-                                        size_t size_bytes);
+  void pw_tokenizer_HandleEncodedMessage(const uint8_t encoded_message[],
+                                         size_t size_bytes);
 
 ``PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD`` is similar, but passes a
 ``uintptr_t`` argument to the global handler function. Values like a log level
@@ -181,7 +181,7 @@
 
 This macro is provided by the ``pw_tokenizer:global_handler_with_payload``
 facade. The backend for this facade must define the
-``pw_TokenizerHandleEncodedMessageWithPayload`` C-linkage function.
+``pw_tokenizer_HandleEncodedMessageWithPayload`` C-linkage function.
 
 .. code-block:: cpp
 
@@ -189,9 +189,8 @@
                                              format_string_literal,
                                              arguments...);
 
-  void pw_TokenizerHandleEncodedMessageWithPayload(uintptr_t payload,
-                                                   const uint8_t encoded_message[],
-                                                   size_t size_bytes);
+  void pw_tokenizer_HandleEncodedMessageWithPayload(
+      uintptr_t payload, const uint8_t encoded_message[], size_t size_bytes);
 
 .. admonition:: When to use these macros
 
@@ -268,19 +267,19 @@
 It is trivial to convert this to a binary log using the tokenizer. The
 ``RecordLog`` call is replaced with a
 ``PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD`` invocation. The
-``pw_TokenizerHandleEncodedMessageWithPayload`` implementation collects the
+``pw_tokenizer_HandleEncodedMessageWithPayload`` implementation collects the
 timestamp and transmits the message with ``TransmitLog``.
 
 .. code-block:: cpp
 
   #define LOG_INFO(format, ...)                   \
       PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD( \
-          (uintptr_t)LogLevel_INFO,                   \
+          (pw_tokenizer_Payload)LogLevel_INFO,    \
           __FILE_NAME__ ":%d " format,            \
           __LINE__,                               \
           __VA_ARGS__);                           \
 
-  extern "C" void pw_TokenizerHandleEncodedMessageWithPayload(
+  extern "C" void pw_tokenizer_HandleEncodedMessageWithPayload(
       uintptr_t level, const uint8_t encoded_message[], size_t size_bytes) {
     if (static_cast<LogLevel>(level) >= current_log_level) {
       TransmitLog(TimeSinceBootMillis(), encoded_message, size_bytes);
@@ -673,12 +672,12 @@
 Encoding
 --------
 To encode with the Base64 format, add a call to
-``pw::tokenizer::PrefixedBase64Encode`` or ``pw_TokenizerPrefixedBase64Encode``
+``pw::tokenizer::PrefixedBase64Encode`` or ``pw_tokenizer_PrefixedBase64Encode``
 in the tokenizer handler function. For example,
 
 .. code-block:: cpp
 
-  void pw_TokenizerHandleEncodedMessage(const uint8_t encoded_message[],
+  void pw_tokenizer_HandleEncodedMessage(const uint8_t encoded_message[],
                                         size_t size_bytes) {
     char base64_buffer[64];
     size_t base64_size = pw::tokenizer::PrefixedBase64Encode(
@@ -707,12 +706,12 @@
    "$pEVTYQkkUmhZam1RPT0=" → "Nested message: $RhYjmQ==" → "Nested message: Wow!"
 
 Base64 decoding is supported in C++ or C with the
-``pw::tokenizer::PrefixedBase64Decode`` or ``pw_TokenizerPrefixedBase64Decode``
+``pw::tokenizer::PrefixedBase64Decode`` or ``pw_tokenizer_PrefixedBase64Decode``
 functions.
 
 .. code-block:: cpp
 
-  void pw_TokenizerHandleEncodedMessage(const uint8_t encoded_message[],
+  void pw_tokenizer_HandleEncodedMessage(const uint8_t encoded_message[],
                                         size_t size_bytes) {
     char base64_buffer[64];
     size_t base64_size = pw::tokenizer::PrefixedBase64Encode(
@@ -780,7 +779,7 @@
   * The log level was passed as the payload argument to facilitate runtime log
     level control.
   * For this project, it was necessary to encode the log messages as text. In
-    ``pw_TokenizerHandleEncodedMessageWithPayload``, the log messages were
+    ``pw_tokenizer_HandleEncodedMessageWithPayload``, the log messages were
     encoded in the $-prefixed `Base64 format`_, then dispatched as normal log
     messages.
   * Asserts were tokenized using ``PW_TOKENIZE_TO_CALLBACK``.
diff --git a/pw_tokenizer/encode_args.cc b/pw_tokenizer/encode_args.cc
index b53cc22..d18e1eb 100644
--- a/pw_tokenizer/encode_args.cc
+++ b/pw_tokenizer/encode_args.cc
@@ -124,7 +124,7 @@
 
 }  // namespace
 
-size_t EncodeArgs(pw_TokenizerArgTypes types,
+size_t EncodeArgs(_pw_tokenizer_ArgTypes types,
                   va_list args,
                   std::span<uint8_t> output) {
   size_t arg_count = types & PW_TOKENIZER_TYPE_COUNT_MASK;
diff --git a/pw_tokenizer/global_handlers_test.cc b/pw_tokenizer/global_handlers_test.cc
index 89885a8..1728a5f 100644
--- a/pw_tokenizer/global_handlers_test.cc
+++ b/pw_tokenizer/global_handlers_test.cc
@@ -104,7 +104,7 @@
 }
 
 TEST_F(TokenizeToGlobalHandler, C_SequentialZigZag) {
-  pw_TokenizeToGlobalHandlerTest_SequentialZigZag();
+  pw_tokenizer_ToGlobalHandlerTest_SequentialZigZag();
 
   constexpr std::array<uint8_t, 18> expected =
       ExpectedData<0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13>(
@@ -113,15 +113,15 @@
   EXPECT_EQ(std::memcmp(expected.data(), message_, expected.size()), 0);
 }
 
-extern "C" void pw_TokenizerHandleEncodedMessage(const uint8_t* encoded_message,
-                                                 size_t size_bytes) {
+extern "C" void pw_tokenizer_HandleEncodedMessage(
+    const uint8_t* encoded_message, size_t size_bytes) {
   TokenizeToGlobalHandler::SetMessage(encoded_message, size_bytes);
 }
 
 class TokenizeToGlobalHandlerWithPayload
     : public GlobalMessage<TokenizeToGlobalHandlerWithPayload> {
  public:
-  static void SetPayload(pw_TokenizerPayload payload) {
+  static void SetPayload(pw_tokenizer_Payload payload) {
     payload_ = static_cast<intptr_t>(payload);
   }
 
@@ -140,13 +140,18 @@
       ExpectedData<0, 0, 0x00, 0x00, 0x00, 0x80, 0>("%x%lld%1.2f%s");
 
   PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD(
-      static_cast<pw_TokenizerPayload>(123), "%x%lld%1.2f%s", 0, 0ll, -0.0, "");
+      static_cast<pw_tokenizer_Payload>(123),
+      "%x%lld%1.2f%s",
+      0,
+      0ll,
+      -0.0,
+      "");
   ASSERT_EQ(expected.size(), message_size_bytes_);
   EXPECT_EQ(std::memcmp(expected.data(), message_, expected.size()), 0);
   EXPECT_EQ(payload_, 123);
 
   PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD(
-      static_cast<pw_TokenizerPayload>(-543),
+      static_cast<pw_tokenizer_Payload>(-543),
       "%x%lld%1.2f%s",
       0,
       0ll,
@@ -170,7 +175,7 @@
 
 TEST_F(TokenizeToGlobalHandlerWithPayload, Strings_NonZeroPayload) {
   PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD(
-      static_cast<pw_TokenizerPayload>(5432), "The answer is: %s", "5432!");
+      static_cast<pw_tokenizer_Payload>(5432), "The answer is: %s", "5432!");
 
   ASSERT_EQ(kExpected.size(), message_size_bytes_);
   EXPECT_EQ(std::memcmp(kExpected.data(), message_, kExpected.size()), 0);
@@ -180,7 +185,7 @@
 TEST_F(TokenizeToGlobalHandlerWithPayload, Domain_Strings) {
   PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD_DOMAIN(
       "TEST_DOMAIN",
-      static_cast<pw_TokenizerPayload>(5432),
+      static_cast<pw_tokenizer_Payload>(5432),
       "The answer is: %s",
       "5432!");
   ASSERT_EQ(kExpected.size(), message_size_bytes_);
@@ -197,7 +202,7 @@
   Foo foo{254u, true};
 
   PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD(
-      reinterpret_cast<pw_TokenizerPayload>(&foo), "Boring!");
+      reinterpret_cast<pw_tokenizer_Payload>(&foo), "Boring!");
 
   constexpr auto expected = ExpectedData("Boring!");
   static_assert(expected.size() == 4);
@@ -211,7 +216,7 @@
 }
 
 TEST_F(TokenizeToGlobalHandlerWithPayload, C_SequentialZigZag) {
-  pw_TokenizeToGlobalHandlerWithPayloadTest_SequentialZigZag();
+  pw_tokenizer_ToGlobalHandlerWithPayloadTest_SequentialZigZag();
 
   constexpr std::array<uint8_t, 18> expected =
       ExpectedData<0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13>(
@@ -221,8 +226,8 @@
   EXPECT_EQ(payload_, 600613);
 }
 
-extern "C" void pw_TokenizerHandleEncodedMessageWithPayload(
-    pw_TokenizerPayload payload,
+extern "C" void pw_tokenizer_HandleEncodedMessageWithPayload(
+    pw_tokenizer_Payload payload,
     const uint8_t* encoded_message,
     size_t size_bytes) {
   TokenizeToGlobalHandlerWithPayload::SetMessage(encoded_message, size_bytes);
@@ -261,7 +266,7 @@
   const char* string_literal = nullptr;
 
   PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD(
-      static_cast<pw_TokenizerPayload>(123), "Wow%s", "???");
+      static_cast<pw_tokenizer_Payload>(123), "Wow%s", "???");
 
   EXPECT_STREQ(tokenizer_domain, PW_TOKENIZER_DEFAULT_DOMAIN);
   EXPECT_STREQ(string_literal, "Wow%s");
@@ -272,7 +277,7 @@
   const char* string_literal = nullptr;
 
   PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD_DOMAIN(
-      "THEDOMAIN", static_cast<pw_TokenizerPayload>(123), "1234567890");
+      "THEDOMAIN", static_cast<pw_tokenizer_Payload>(123), "1234567890");
 
   EXPECT_STREQ(tokenizer_domain, "THEDOMAIN");
   EXPECT_STREQ(string_literal, "1234567890");
diff --git a/pw_tokenizer/global_handlers_test_c.c b/pw_tokenizer/global_handlers_test_c.c
index e0619e5..04d5551 100644
--- a/pw_tokenizer/global_handlers_test_c.c
+++ b/pw_tokenizer/global_handlers_test_c.c
@@ -26,7 +26,7 @@
 // This test invokes the tokenization API with a variety of types. To simplify
 // validating the encoded data, numbers that are sequential when zig-zag encoded
 // are used as arguments.
-void pw_TokenizeToGlobalHandlerTest_SequentialZigZag(void) {
+void pw_tokenizer_ToGlobalHandlerTest_SequentialZigZag(void) {
   PW_TOKENIZE_TO_GLOBAL_HANDLER(TEST_FORMAT_SEQUENTIAL_ZIG_ZAG,
                                 0u,
                                 -1,
@@ -44,8 +44,8 @@
                                 (signed char)-7);
 }
 
-void pw_TokenizeToGlobalHandlerWithPayloadTest_SequentialZigZag(void) {
-  PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD((pw_TokenizerPayload)600613,
+void pw_tokenizer_ToGlobalHandlerWithPayloadTest_SequentialZigZag(void) {
+  PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD((pw_tokenizer_Payload)600613,
                                              TEST_FORMAT_SEQUENTIAL_ZIG_ZAG,
                                              0u,
                                              -1,
diff --git a/pw_tokenizer/public/pw_tokenizer/base64.h b/pw_tokenizer/public/pw_tokenizer/base64.h
index bf84e29..e91e66d 100644
--- a/pw_tokenizer/public/pw_tokenizer/base64.h
+++ b/pw_tokenizer/public/pw_tokenizer/base64.h
@@ -43,20 +43,20 @@
 // too small.
 //
 // Equivalent to pw::tokenizer::PrefixedBase64Encode.
-size_t pw_TokenizerPrefixedBase64Encode(const void* binary_message,
-                                        size_t binary_size_bytes,
-                                        void* output_buffer,
-                                        size_t output_buffer_size_bytes);
+size_t pw_tokenizer_PrefixedBase64Encode(const void* binary_message,
+                                         size_t binary_size_bytes,
+                                         void* output_buffer,
+                                         size_t output_buffer_size_bytes);
 // Decodes a prefixed Base64 tokenized message to binary. Returns the size of
 // the decoded binary data. The resulting data is ready to be passed to
 // pw::tokenizer::Detokenizer::Detokenize. Returns 0 if the buffer is too small,
 // the expected prefix character is missing, or the Base64 data is corrupt.
 //
 // Equivalent to pw::tokenizer::PrefixedBase64Encode.
-size_t pw_TokenizerPrefixedBase64Decode(const void* base64_message,
-                                        size_t base64_size_bytes,
-                                        void* output_buffer,
-                                        size_t output_buffer_size);
+size_t pw_tokenizer_PrefixedBase64Decode(const void* base64_message,
+                                         size_t base64_size_bytes,
+                                         void* output_buffer,
+                                         size_t output_buffer_size);
 
 PW_EXTERN_C_END
 
@@ -74,10 +74,10 @@
 // too small or does not start with kBase64Prefix.
 inline size_t PrefixedBase64Encode(std::span<const std::byte> binary_message,
                                    std::span<char> output_buffer) {
-  return pw_TokenizerPrefixedBase64Encode(binary_message.data(),
-                                          binary_message.size(),
-                                          output_buffer.data(),
-                                          output_buffer.size());
+  return pw_tokenizer_PrefixedBase64Encode(binary_message.data(),
+                                           binary_message.size(),
+                                           output_buffer.data(),
+                                           output_buffer.size());
 }
 
 // Also accept a std::span<const uint8_t> for the binary message.
@@ -91,16 +91,16 @@
 // pw::tokenizer::Detokenizer::Detokenize.
 inline size_t PrefixedBase64Decode(std::string_view base64_message,
                                    std::span<std::byte> output_buffer) {
-  return pw_TokenizerPrefixedBase64Decode(base64_message.data(),
-                                          base64_message.size(),
-                                          output_buffer.data(),
-                                          output_buffer.size());
+  return pw_tokenizer_PrefixedBase64Decode(base64_message.data(),
+                                           base64_message.size(),
+                                           output_buffer.data(),
+                                           output_buffer.size());
 }
 
 // Decodes a prefixed Base64 tokenized message to binary in place. Returns the
 // size of the decoded binary data.
 inline size_t PrefixedBase64DecodeInPlace(std::span<std::byte> buffer) {
-  return pw_TokenizerPrefixedBase64Decode(
+  return pw_tokenizer_PrefixedBase64Decode(
       buffer.data(), buffer.size(), buffer.data(), buffer.size());
 }
 
diff --git a/pw_tokenizer/public/pw_tokenizer/internal/argument_types.h b/pw_tokenizer/public/pw_tokenizer/internal/argument_types.h
index ecff29d..8611577 100644
--- a/pw_tokenizer/public/pw_tokenizer/internal/argument_types.h
+++ b/pw_tokenizer/public/pw_tokenizer/internal/argument_types.h
@@ -31,7 +31,7 @@
 #define PW_TOKENIZER_TYPE_COUNT_SIZE_BITS 4u
 #define PW_TOKENIZER_TYPE_COUNT_MASK 0x0Fu
 
-typedef uint32_t pw_TokenizerArgTypes;
+typedef uint32_t _pw_tokenizer_ArgTypes;
 
 #elif PW_TOKENIZER_CFG_ARG_TYPES_SIZE_BYTES == 8
 
@@ -42,7 +42,7 @@
 #define PW_TOKENIZER_TYPE_COUNT_SIZE_BITS 6u
 #define PW_TOKENIZER_TYPE_COUNT_MASK 0x1Fu  // only 5 bits will be needed
 
-typedef uint64_t pw_TokenizerArgTypes;
+typedef uint64_t _pw_tokenizer_ArgTypes;
 
 #else
 
@@ -52,7 +52,7 @@
 
 // The tokenized string encoding function is a variadic function that works
 // similarly to printf. Instead of a format string, however, the argument types
-// are packed into a pw_TokenizerArgTypes.
+// are packed into a _pw_tokenizer_ArgTypes.
 //
 // The four supported argument types are represented by two-bit argument codes.
 // Just four types are required because only printf-compatible arguments are
@@ -62,10 +62,10 @@
 // char* values cannot be printed as pointers with %p. These arguments are
 // always encoded as strings. To format a char* as an address, cast it to void*
 // or an integer.
-#define PW_TOKENIZER_ARG_TYPE_INT ((pw_TokenizerArgTypes)0)
-#define PW_TOKENIZER_ARG_TYPE_INT64 ((pw_TokenizerArgTypes)1)
-#define PW_TOKENIZER_ARG_TYPE_DOUBLE ((pw_TokenizerArgTypes)2)
-#define PW_TOKENIZER_ARG_TYPE_STRING ((pw_TokenizerArgTypes)3)
+#define PW_TOKENIZER_ARG_TYPE_INT ((_pw_tokenizer_ArgTypes)0)
+#define PW_TOKENIZER_ARG_TYPE_INT64 ((_pw_tokenizer_ArgTypes)1)
+#define PW_TOKENIZER_ARG_TYPE_DOUBLE ((_pw_tokenizer_ArgTypes)2)
+#define PW_TOKENIZER_ARG_TYPE_STRING ((_pw_tokenizer_ArgTypes)3)
 
 // Select the int argument type based on the size of the type. Values smaller
 // than int are promoted to int.
@@ -89,7 +89,7 @@
 
 // This function selects the matching type enum for supported argument types.
 template <typename T>
-constexpr pw_TokenizerArgTypes VarargsType() {
+constexpr _pw_tokenizer_ArgTypes VarargsType() {
   using ArgType = std::decay_t<T>;
 
   if constexpr (std::is_floating_point<ArgType>()) {
@@ -116,26 +116,26 @@
 
 template <typename T, bool kDontCare1, bool kDontCare2>
 struct SelectVarargsType<T, true, kDontCare1, kDontCare2> {
-  static constexpr pw_TokenizerArgTypes kValue = PW_TOKENIZER_ARG_TYPE_DOUBLE;
+  static constexpr _pw_tokenizer_ArgTypes kValue = PW_TOKENIZER_ARG_TYPE_DOUBLE;
 };
 
 template <typename T, bool kDontCare>
 struct SelectVarargsType<T, false, true, kDontCare> {
-  static constexpr pw_TokenizerArgTypes kValue = PW_TOKENIZER_ARG_TYPE_STRING;
+  static constexpr _pw_tokenizer_ArgTypes kValue = PW_TOKENIZER_ARG_TYPE_STRING;
 };
 
 template <typename T>
 struct SelectVarargsType<T, false, false, true> {
-  static constexpr pw_TokenizerArgTypes kValue = PW_TOKENIZER_ARG_TYPE_INT64;
+  static constexpr _pw_tokenizer_ArgTypes kValue = PW_TOKENIZER_ARG_TYPE_INT64;
 };
 
 template <typename T>
 struct SelectVarargsType<T, false, false, false> {
-  static constexpr pw_TokenizerArgTypes kValue = PW_TOKENIZER_ARG_TYPE_INT;
+  static constexpr _pw_tokenizer_ArgTypes kValue = PW_TOKENIZER_ARG_TYPE_INT;
 };
 
 template <typename T>
-constexpr pw_TokenizerArgTypes VarargsType() {
+constexpr _pw_tokenizer_ArgTypes VarargsType() {
   return SelectVarargsType<typename std::decay<T>::type>::kValue;
 }
 
@@ -174,14 +174,14 @@
 
 #endif  // __cplusplus
 
-// Encodes the types of the provided arguments as a pw_TokenizerArgTypes value.
-// Depending on the size of pw_TokenizerArgTypes, the bottom 4 or 6 bits store
-// the number of arguments and the remaining bits store the types, two bits per
-// type.
+// Encodes the types of the provided arguments as a _pw_tokenizer_ArgTypes
+// value. Depending on the size of _pw_tokenizer_ArgTypes, the bottom 4 or 6
+// bits store the number of arguments and the remaining bits store the types,
+// two bits per type.
 //
 // The arguments are not evaluated; only their types are used to
 // select the set their corresponding PW_TOKENIZER_ARG_TYPEs.
 #define PW_TOKENIZER_ARG_TYPES(...) \
   PW_DELEGATE_BY_ARG_COUNT(_PW_TOKENIZER_TYPES_, __VA_ARGS__)
 
-#define _PW_TOKENIZER_TYPES_0() ((pw_TokenizerArgTypes)0)
+#define _PW_TOKENIZER_TYPES_0() ((_pw_tokenizer_ArgTypes)0)
diff --git a/pw_tokenizer/public/pw_tokenizer/internal/tokenize_string.h b/pw_tokenizer/public/pw_tokenizer/internal/tokenize_string.h
index 27434bd..73d2739 100644
--- a/pw_tokenizer/public/pw_tokenizer/internal/tokenize_string.h
+++ b/pw_tokenizer/public/pw_tokenizer/internal/tokenize_string.h
@@ -64,6 +64,3 @@
 #endif  // PW_TOKENIZER_CFG_HASH_LENGTH
 
 #endif  // __cpp_constexpr >= 201304L && defined(__cpp_inline_variables)
-
-// The type of the token used in place of a format string.
-typedef uint32_t pw_TokenizerStringToken;
diff --git a/pw_tokenizer/public/pw_tokenizer/tokenize.h b/pw_tokenizer/public/pw_tokenizer/tokenize.h
index c988fe5..94a076e 100644
--- a/pw_tokenizer/public/pw_tokenizer/tokenize.h
+++ b/pw_tokenizer/public/pw_tokenizer/tokenize.h
@@ -34,6 +34,10 @@
 #include "pw_tokenizer/internal/argument_types.h"
 #include "pw_tokenizer/internal/tokenize_string.h"
 
+// The type of the token used in place of a format string. Also available as
+// pw::tokenizer::Token.
+typedef uint32_t pw_tokenizer_Token;
+
 // Strings may optionally be tokenized to a domain. Strings in different domains
 // can be processed separately by the token database tools. Each domain in use
 // must have a corresponding section declared in the linker script. See
@@ -42,7 +46,7 @@
 // If no domain is specified, this default is used.
 #define PW_TOKENIZER_DEFAULT_DOMAIN "default"
 
-// Tokenizes a string and converts it to a pw_TokenizerStringToken. In C++, the
+// Tokenizes a string and converts it to a pw_tokenizer_Token. In C++, the
 // string may be a literal or a constexpr char array. In C, the argument must be
 // a string literal.
 //
@@ -94,15 +98,15 @@
                                __VA_ARGS__)
 
 // Same as PW_TOKENIZE_TO_BUFFER, but tokenizes to the specified domain.
-#define PW_TOKENIZE_TO_BUFFER_DOMAIN(                        \
-    domain, buffer, buffer_size_pointer, format, ...)        \
-  do {                                                       \
-    _PW_TOKENIZE_FORMAT_STRING(domain, format, __VA_ARGS__); \
-    _pw_TokenizeToBuffer(buffer,                             \
-                         buffer_size_pointer,                \
-                         _pw_tokenizer_token,                \
-                         PW_TOKENIZER_ARG_TYPES(__VA_ARGS__) \
-                             PW_COMMA_ARGS(__VA_ARGS__));    \
+#define PW_TOKENIZE_TO_BUFFER_DOMAIN(                          \
+    domain, buffer, buffer_size_pointer, format, ...)          \
+  do {                                                         \
+    _PW_TOKENIZE_FORMAT_STRING(domain, format, __VA_ARGS__);   \
+    _pw_tokenizer_ToBuffer(buffer,                             \
+                           buffer_size_pointer,                \
+                           _pw_tokenizer_token,                \
+                           PW_TOKENIZER_ARG_TYPES(__VA_ARGS__) \
+                               PW_COMMA_ARGS(__VA_ARGS__));    \
   } while (0)
 
 // Encodes a tokenized string and arguments to a buffer on the stack. The
@@ -140,33 +144,33 @@
 #define PW_TOKENIZE_TO_CALLBACK_DOMAIN(domain, callback, format, ...) \
   do {                                                                \
     _PW_TOKENIZE_FORMAT_STRING(domain, format, __VA_ARGS__);          \
-    _pw_TokenizeToCallback(callback,                                  \
-                           _pw_tokenizer_token,                       \
-                           PW_TOKENIZER_ARG_TYPES(__VA_ARGS__)        \
-                               PW_COMMA_ARGS(__VA_ARGS__));           \
+    _pw_tokenizer_ToCallback(callback,                                \
+                             _pw_tokenizer_token,                     \
+                             PW_TOKENIZER_ARG_TYPES(__VA_ARGS__)      \
+                                 PW_COMMA_ARGS(__VA_ARGS__));         \
   } while (0)
 
 PW_EXTERN_C_START
 
 // These functions encode the tokenized strings. These should not be called
 // directly. Instead, use the corresponding PW_TOKENIZE_TO_* macros above.
-void _pw_TokenizeToBuffer(void* buffer,
-                          size_t* buffer_size_bytes,  // input and output arg
-                          pw_TokenizerStringToken token,
-                          pw_TokenizerArgTypes types,
-                          ...);
-
-void _pw_TokenizeToCallback(void (*callback)(const uint8_t* encoded_message,
-                                             size_t size_bytes),
-                            pw_TokenizerStringToken token,
-                            pw_TokenizerArgTypes types,
+void _pw_tokenizer_ToBuffer(void* buffer,
+                            size_t* buffer_size_bytes,  // input and output arg
+                            pw_tokenizer_Token token,
+                            _pw_tokenizer_ArgTypes types,
                             ...);
 
+void _pw_tokenizer_ToCallback(void (*callback)(const uint8_t* encoded_message,
+                                               size_t size_bytes),
+                              pw_tokenizer_Token token,
+                              _pw_tokenizer_ArgTypes types,
+                              ...);
+
 // This empty function allows the compiler to check the format string.
-inline void pw_TokenizerCheckFormatString(const char* format, ...)
+static inline void pw_tokenizer_CheckFormatString(const char* format, ...)
     PW_PRINTF_FORMAT(1, 2);
 
-inline void pw_TokenizerCheckFormatString(const char* format, ...) {
+static inline void pw_tokenizer_CheckFormatString(const char* format, ...) {
   PW_UNUSED(format);
 }
 
@@ -179,9 +183,9 @@
 // checks that the arguments are correct, stores the format string in a special
 // section, and calculates the string's token at compile time.
 // clang-format off
-#define _PW_TOKENIZE_FORMAT_STRING(domain, format, ...)                     \
+#define _PW_TOKENIZE_FORMAT_STRING(domain, format, ...)                        \
   if (0) { /* Do not execute to prevent double evaluation of the arguments. */ \
-    pw_TokenizerCheckFormatString(format PW_COMMA_ARGS(__VA_ARGS__));          \
+    pw_tokenizer_CheckFormatString(format PW_COMMA_ARGS(__VA_ARGS__));         \
   }                                                                            \
                                                                                \
   /* Check that the macro is invoked with a supported number of arguments. */  \
@@ -192,16 +196,28 @@
       PW_STRINGIFY(PW_ARG_COUNT(__VA_ARGS__)) " arguments were used for "      \
       #format " (" #__VA_ARGS__ ")");                                          \
                                                                                \
-  /* Tokenize the string to a pw_TokenizerStringToken at compile time. */      \
-  _PW_TOKENIZER_CONST pw_TokenizerStringToken _pw_tokenizer_token =            \
+  /* Tokenize the string to a pw_tokenizer_Token at compile time. */           \
+  _PW_TOKENIZER_CONST pw_tokenizer_Token _pw_tokenizer_token =                 \
       PW_TOKENIZE_STRING_DOMAIN(domain, format)
 
 // clang-format on
 
 #ifdef __cplusplus  // use constexpr for C++
+
 #define _PW_TOKENIZER_CONST constexpr
+
+namespace pw {
+namespace tokenizer {
+
+using Token = ::pw_tokenizer_Token;
+
+}  // namespace tokenizer
+}  // namespace pw
+
 #else  // use const for C
+
 #define _PW_TOKENIZER_CONST const
+
 #endif  // __cplusplus
 
 // _PW_TOKENIZER_SECTION places the format string in a special .pw_tokenized
diff --git a/pw_tokenizer/public/pw_tokenizer/tokenize_to_global_handler.h b/pw_tokenizer/public/pw_tokenizer/tokenize_to_global_handler.h
index ce41741..e973326 100644
--- a/pw_tokenizer/public/pw_tokenizer/tokenize_to_global_handler.h
+++ b/pw_tokenizer/public/pw_tokenizer/tokenize_to_global_handler.h
@@ -20,7 +20,7 @@
 #include "pw_tokenizer/tokenize.h"
 
 // Encodes a tokenized string and arguments to a buffer on the stack. The buffer
-// is passed to the user-defined pw_TokenizerHandleEncodedMessage function. The
+// is passed to the user-defined pw_tokenizer_HandleEncodedMessage function. The
 // size of the stack-allocated argument encoding buffer is set with the
 // PW_TOKENIZER_CFG_ENCODING_BUFFER_SIZE_BYTES option.
 //
@@ -31,13 +31,13 @@
 //
 // For example, the following encodes a tokenized string with a value returned
 // from a function call. The encoded message is passed to the caller-defined
-// pw_TokenizerHandleEncodedMessage function.
+// pw_tokenizer_HandleEncodedMessage function.
 //
 //   void OutputLastReadSize() {
 //     PW_TOKENIZE_TO_GLOBAL_HANDLER("Read %u bytes", ReadSizeBytes());
 //   }
 //
-//   void pw_TokenizerHandleEncodedMessage(const uint8_t encoded_message[],
+//   void pw_tokenizer_HandleEncodedMessage(const uint8_t encoded_message[],
 //                                         size_t size_bytes) {
 //     MyProject_EnqueueMessageForUart(buffer, size_bytes);
 //   }
@@ -47,26 +47,30 @@
       PW_TOKENIZER_DEFAULT_DOMAIN, format, __VA_ARGS__)
 
 // Same as PW_TOKENIZE_TO_GLOBAL_HANDLER, but tokenizes to the specified domain.
-#define PW_TOKENIZE_TO_GLOBAL_HANDLER_DOMAIN(domain, format, ...)   \
-  do {                                                              \
-    _PW_TOKENIZE_FORMAT_STRING(domain, format, __VA_ARGS__);        \
-    _pw_TokenizeToGlobalHandler(_pw_tokenizer_token,                \
-                                PW_TOKENIZER_ARG_TYPES(__VA_ARGS__) \
-                                    PW_COMMA_ARGS(__VA_ARGS__));    \
+#define PW_TOKENIZE_TO_GLOBAL_HANDLER_DOMAIN(domain, format, ...)     \
+  do {                                                                \
+    _PW_TOKENIZE_FORMAT_STRING(domain, format, __VA_ARGS__);          \
+    _pw_tokenizer_ToGlobalHandler(_pw_tokenizer_token,                \
+                                  PW_TOKENIZER_ARG_TYPES(__VA_ARGS__) \
+                                      PW_COMMA_ARGS(__VA_ARGS__));    \
   } while (0)
 
 PW_EXTERN_C_START
 
 // This function must be defined by the pw_tokenizer:global_handler backend.
 // This function is called with the encoded message by
-// pw_TokenizeToGlobalHandler.
-void pw_TokenizerHandleEncodedMessage(const uint8_t encoded_message[],
-                                      size_t size_bytes);
+// _pw_tokenizer_ToGlobalHandler.
+void pw_tokenizer_HandleEncodedMessage(const uint8_t encoded_message[],
+                                       size_t size_bytes);
+
+// TODO(hepler): Remove this alias when all projects have migrated to the new
+//     function name.
+#define pw_TokenizerHandleEncodedMessage pw_tokenizer_HandleEncodedMessage
 
 // This function encodes the tokenized strings. Do not call it directly;
 // instead, use the PW_TOKENIZE_TO_GLOBAL_HANDLER macro.
-void _pw_TokenizeToGlobalHandler(pw_TokenizerStringToken token,
-                                 pw_TokenizerArgTypes types,
-                                 ...);
+void _pw_tokenizer_ToGlobalHandler(pw_tokenizer_Token token,
+                                   _pw_tokenizer_ArgTypes types,
+                                   ...);
 
 PW_EXTERN_C_END
diff --git a/pw_tokenizer/public/pw_tokenizer/tokenize_to_global_handler_with_payload.h b/pw_tokenizer/public/pw_tokenizer/tokenize_to_global_handler_with_payload.h
index df1800f..0b1fe51 100644
--- a/pw_tokenizer/public/pw_tokenizer/tokenize_to_global_handler_with_payload.h
+++ b/pw_tokenizer/public/pw_tokenizer/tokenize_to_global_handler_with_payload.h
@@ -22,7 +22,7 @@
 // Like PW_TOKENIZE_TO_GLOBAL_HANDLER, encodes a tokenized string and arguments
 // to a buffer on the stack. The macro adds a payload argument, which is passed
 // through to the global handler function
-// pw_TokenizerHandleEncodedMessageWithPayload, which must be defined by the
+// pw_tokenizer_HandleEncodedMessageWithPayload, which must be defined by the
 // user of pw_tokenizer. The payload is a uintptr_t.
 //
 // For example, the following tokenizes a log string and passes the log level as
@@ -31,8 +31,8 @@
      #define LOG_ERROR(...) \
          PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD(kLogLevelError, __VA_ARGS__)
 
-     void pw_TokenizerHandleEncodedMessageWithPayload(
-         pw_TokenizerPayload log_level,
+     void pw_tokenizer_HandleEncodedMessageWithPayload(
+         pw_tokenizer_Payload log_level,
          const uint8_t encoded_message[],
          size_t size_bytes) {
        if (log_level >= kLogLevelWarning) {
@@ -46,33 +46,42 @@
 
 // Same as PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD, but tokenizes to the
 // specified domain.
-#define PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD_DOMAIN(                     \
-    domain, payload, format, ...)                                              \
-  do {                                                                         \
-    _PW_TOKENIZE_FORMAT_STRING(domain, format, __VA_ARGS__);                   \
-    _pw_TokenizeToGlobalHandlerWithPayload(payload,                            \
-                                           _pw_tokenizer_token,                \
-                                           PW_TOKENIZER_ARG_TYPES(__VA_ARGS__) \
-                                               PW_COMMA_ARGS(__VA_ARGS__));    \
+#define PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD_DOMAIN(               \
+    domain, payload, format, ...)                                        \
+  do {                                                                   \
+    _PW_TOKENIZE_FORMAT_STRING(domain, format, __VA_ARGS__);             \
+    _pw_tokenizer_ToGlobalHandlerWithPayload(                            \
+        payload,                                                         \
+        _pw_tokenizer_token,                                             \
+        PW_TOKENIZER_ARG_TYPES(__VA_ARGS__) PW_COMMA_ARGS(__VA_ARGS__)); \
   } while (0)
 
 PW_EXTERN_C_START
 
-typedef uintptr_t pw_TokenizerPayload;
+typedef uintptr_t pw_tokenizer_Payload;
+
+// TODO(hepler): Remove this alias when all projects have migrated to the new
+//     typedef name.
+typedef pw_tokenizer_Payload pw_TokenizerPayload;
 
 // This function must be defined pw_tokenizer:global_handler_with_payload
 // backend. This function is called with the encoded message by
-// pw_TokenizeToGlobalHandler and a caller-provided payload argument.
-void pw_TokenizerHandleEncodedMessageWithPayload(
-    pw_TokenizerPayload payload,
+// pw_tokenizer_ToGlobalHandler and a caller-provided payload argument.
+void pw_tokenizer_HandleEncodedMessageWithPayload(
+    pw_tokenizer_Payload payload,
     const uint8_t encoded_message[],
     size_t size_bytes);
 
+// TODO(hepler): Remove this alias when all projects have migrated to the new
+//     function name.
+#define pw_TokenizerHandleEncodedMessageWithPayload \
+  pw_tokenizer_HandleEncodedMessageWithPayload
+
 // This function encodes the tokenized strings. Do not call it directly;
 // instead, use the PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD macro.
-void _pw_TokenizeToGlobalHandlerWithPayload(pw_TokenizerPayload payload,
-                                            pw_TokenizerStringToken token,
-                                            pw_TokenizerArgTypes types,
-                                            ...);
+void _pw_tokenizer_ToGlobalHandlerWithPayload(pw_tokenizer_Payload payload,
+                                              pw_tokenizer_Token token,
+                                              _pw_tokenizer_ArgTypes types,
+                                              ...);
 
 PW_EXTERN_C_END
diff --git a/pw_tokenizer/pw_tokenizer_private/argument_types_test.h b/pw_tokenizer/pw_tokenizer_private/argument_types_test.h
index 52ac6c9..b616392 100644
--- a/pw_tokenizer/pw_tokenizer_private/argument_types_test.h
+++ b/pw_tokenizer/pw_tokenizer_private/argument_types_test.h
@@ -20,27 +20,27 @@
 
 PW_EXTERN_C_START
 
-pw_TokenizerArgTypes pw_TestTokenizerNoArgs(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerNoArgs(void);
 
-pw_TokenizerArgTypes pw_TestTokenizerChar(void);
-pw_TokenizerArgTypes pw_TestTokenizerUint8(void);
-pw_TokenizerArgTypes pw_TestTokenizerUint16(void);
-pw_TokenizerArgTypes pw_TestTokenizerInt32(void);
-pw_TokenizerArgTypes pw_TestTokenizerInt64(void);
-pw_TokenizerArgTypes pw_TestTokenizerUint64(void);
-pw_TokenizerArgTypes pw_TestTokenizerFloat(void);
-pw_TokenizerArgTypes pw_TestTokenizerDouble(void);
-pw_TokenizerArgTypes pw_TestTokenizerString(void);
-pw_TokenizerArgTypes pw_TestTokenizerMutableString(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerChar(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerUint8(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerUint16(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerInt32(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerInt64(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerUint64(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerFloat(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerDouble(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerString(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerMutableString(void);
 
-pw_TokenizerArgTypes pw_TestTokenizerIntFloat(void);
-pw_TokenizerArgTypes pw_TestTokenizerUint64Char(void);
-pw_TokenizerArgTypes pw_TestTokenizerStringString(void);
-pw_TokenizerArgTypes pw_TestTokenizerUint16Int(void);
-pw_TokenizerArgTypes pw_TestTokenizerFloatString(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerIntFloat(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerUint64Char(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerStringString(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerUint16Int(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerFloatString(void);
 
-pw_TokenizerArgTypes pw_TestTokenizerNull(void);
-pw_TokenizerArgTypes pw_TestTokenizerPointer(void);
-pw_TokenizerArgTypes pw_TestTokenizerPointerPointer(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerNull(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerPointer(void);
+_pw_tokenizer_ArgTypes pw_TestTokenizerPointerPointer(void);
 
 PW_EXTERN_C_END
diff --git a/pw_tokenizer/pw_tokenizer_private/encode_args.h b/pw_tokenizer/pw_tokenizer_private/encode_args.h
index 2f39949..7a85963 100644
--- a/pw_tokenizer/pw_tokenizer_private/encode_args.h
+++ b/pw_tokenizer/pw_tokenizer_private/encode_args.h
@@ -20,23 +20,24 @@
 
 #include "pw_tokenizer/config.h"
 #include "pw_tokenizer/internal/argument_types.h"
-#include "pw_tokenizer/internal/tokenize_string.h"
+#include "pw_tokenizer/tokenize.h"
 
 namespace pw {
 namespace tokenizer {
 
 // Buffer for encoding a tokenized string and arguments.
 struct EncodedMessage {
-  pw_TokenizerStringToken token;
+  pw_tokenizer_Token token;
   std::array<uint8_t, PW_TOKENIZER_CFG_ENCODING_BUFFER_SIZE_BYTES> args;
 };
 
 static_assert(offsetof(EncodedMessage, args) == sizeof(EncodedMessage::token),
               "EncodedMessage should not have padding bytes between members");
 
-// Encodes a tokenized string's arguments to a buffer. The pw_TokenizerArgTypes
-// parameter specifies the argument types, in place of a format string.
-size_t EncodeArgs(pw_TokenizerArgTypes types,
+// Encodes a tokenized string's arguments to a buffer. The
+// _pw_tokenizer_ArgTypes parameter specifies the argument types, in place of a
+// format string.
+size_t EncodeArgs(_pw_tokenizer_ArgTypes types,
                   va_list args,
                   std::span<uint8_t> output);
 
diff --git a/pw_tokenizer/pw_tokenizer_private/tokenize_test.h b/pw_tokenizer/pw_tokenizer_private/tokenize_test.h
index d67764a..3c4b463 100644
--- a/pw_tokenizer/pw_tokenizer_private/tokenize_test.h
+++ b/pw_tokenizer/pw_tokenizer_private/tokenize_test.h
@@ -25,23 +25,23 @@
 
 #define TEST_FORMAT_STRING_SHORT_FLOAT "Hello %s! %hd %e"
 
-void pw_TokenizeToBufferTest_StringShortFloat(void* buffer,
-                                              size_t* buffer_size);
+void pw_tokenizer_ToBufferTest_StringShortFloat(void* buffer,
+                                                size_t* buffer_size);
 
 #define TEST_FORMAT_SEQUENTIAL_ZIG_ZAG "%u%d%02x%X%hu%hhd%d%ld%lu%lld%llu%c%c%c"
 
-void pw_TokenizeToBufferTest_SequentialZigZag(void* buffer,
-                                              size_t* buffer_size);
+void pw_tokenizer_ToBufferTest_SequentialZigZag(void* buffer,
+                                                size_t* buffer_size);
 
-void pw_TokenizeToCallbackTest_SequentialZigZag(
+void pw_tokenizer_ToCallbackTest_SequentialZigZag(
     void (*callback)(const uint8_t* buffer, size_t size));
 
 #define TEST_FORMAT_REQUIRES_8 "Won't fit : %s%d"
 
-void pw_TokenizeToBufferTest_Requires8(void* buffer, size_t* buffer_size);
+void pw_tokenizer_ToBufferTest_Requires8(void* buffer, size_t* buffer_size);
 
-void pw_TokenizeToGlobalHandlerTest_SequentialZigZag(void);
+void pw_tokenizer_ToGlobalHandlerTest_SequentialZigZag(void);
 
-void pw_TokenizeToGlobalHandlerWithPayloadTest_SequentialZigZag(void);
+void pw_tokenizer_ToGlobalHandlerWithPayloadTest_SequentialZigZag(void);
 
 PW_EXTERN_C_END
diff --git a/pw_tokenizer/simple_tokenize_test.cc b/pw_tokenizer/simple_tokenize_test.cc
index ac00c91..ba6a5a8 100644
--- a/pw_tokenizer/simple_tokenize_test.cc
+++ b/pw_tokenizer/simple_tokenize_test.cc
@@ -50,7 +50,7 @@
 }
 
 TEST(TokenizeStringLiteral, EmptyString_IsZero) {
-  constexpr pw_TokenizerStringToken token = PW_TOKENIZE_STRING("");
+  constexpr pw_tokenizer_Token token = PW_TOKENIZE_STRING("");
   EXPECT_TRUE(0u == token);
 }
 
@@ -139,15 +139,15 @@
   EXPECT_TRUE(std::memcmp(expected.data(), message_, expected.size()) == 0);
 }
 
-extern "C" void pw_TokenizerHandleEncodedMessage(const uint8_t* encoded_message,
-                                                 size_t size_bytes) {
+extern "C" void pw_tokenizer_HandleEncodedMessage(
+    const uint8_t* encoded_message, size_t size_bytes) {
   TokenizeToGlobalHandler::SetMessage(encoded_message, size_bytes);
 }
 
 class TokenizeToGlobalHandlerWithPayload
     : public GlobalMessage<TokenizeToGlobalHandlerWithPayload> {
  public:
-  static void SetPayload(pw_TokenizerPayload payload) {
+  static void SetPayload(pw_tokenizer_Payload payload) {
     payload_ = static_cast<intptr_t>(payload);
   }
 
@@ -166,13 +166,18 @@
       ExpectedData<0, 0, 0x00, 0x00, 0x00, 0x80, 0>("%x%lld%1.2f%s");
 
   PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD(
-      static_cast<pw_TokenizerPayload>(123), "%x%lld%1.2f%s", 0, 0ll, -0.0, "");
+      static_cast<pw_tokenizer_Payload>(123),
+      "%x%lld%1.2f%s",
+      0,
+      0ll,
+      -0.0,
+      "");
   ASSERT_TRUE(expected.size() == message_size_bytes_);
   EXPECT_TRUE(std::memcmp(expected.data(), message_, expected.size()) == 0);
   EXPECT_TRUE(payload_ == 123);
 
   PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD(
-      static_cast<pw_TokenizerPayload>(-543),
+      static_cast<pw_tokenizer_Payload>(-543),
       "%x%lld%1.2f%s",
       0,
       0ll,
@@ -183,8 +188,8 @@
   EXPECT_TRUE(payload_ == -543);
 }
 
-extern "C" void pw_TokenizerHandleEncodedMessageWithPayload(
-    pw_TokenizerPayload payload,
+extern "C" void pw_tokenizer_HandleEncodedMessageWithPayload(
+    pw_tokenizer_Payload payload,
     const uint8_t* encoded_message,
     size_t size_bytes) {
   TokenizeToGlobalHandlerWithPayload::SetMessage(encoded_message, size_bytes);
diff --git a/pw_tokenizer/tokenize.cc b/pw_tokenizer/tokenize.cc
index 8b1a20a..57e1115 100644
--- a/pw_tokenizer/tokenize.cc
+++ b/pw_tokenizer/tokenize.cc
@@ -25,11 +25,11 @@
 namespace pw {
 namespace tokenizer {
 
-extern "C" void _pw_TokenizeToBuffer(void* buffer,
-                                     size_t* buffer_size_bytes,
-                                     pw_TokenizerStringToken token,
-                                     pw_TokenizerArgTypes types,
-                                     ...) {
+extern "C" void _pw_tokenizer_ToBuffer(void* buffer,
+                                       size_t* buffer_size_bytes,
+                                       Token token,
+                                       _pw_tokenizer_ArgTypes types,
+                                       ...) {
   if (*buffer_size_bytes < sizeof(token)) {
     *buffer_size_bytes = 0;
     return;
@@ -49,10 +49,10 @@
   *buffer_size_bytes = sizeof(token) + encoded_bytes;
 }
 
-extern "C" void _pw_TokenizeToCallback(
+extern "C" void _pw_tokenizer_ToCallback(
     void (*callback)(const uint8_t* encoded_message, size_t size_bytes),
-    pw_TokenizerStringToken token,
-    pw_TokenizerArgTypes types,
+    Token token,
+    _pw_tokenizer_ArgTypes types,
     ...) {
   EncodedMessage encoded;
   encoded.token = token;
diff --git a/pw_tokenizer/tokenize_test.cc b/pw_tokenizer/tokenize_test.cc
index cd96681..6a64c1a 100644
--- a/pw_tokenizer/tokenize_test.cc
+++ b/pw_tokenizer/tokenize_test.cc
@@ -52,7 +52,7 @@
 }
 
 TEST(TokenizeString, EmptyString_IsZero) {
-  constexpr pw_TokenizerStringToken token = PW_TOKENIZE_STRING("");
+  constexpr pw_tokenizer_Token token = PW_TOKENIZE_STRING("");
   EXPECT_EQ(0u, token);
 }
 
@@ -364,7 +364,7 @@
 
 TEST_F(TokenizeToBuffer, C_StringShortFloat) {
   size_t size = sizeof(buffer_);
-  pw_TokenizeToBufferTest_StringShortFloat(buffer_, &size);
+  pw_tokenizer_ToBufferTest_StringShortFloat(buffer_, &size);
   constexpr std::array<uint8_t, 11> expected =  // clang-format off
       ExpectedData<1, '1',                 // string '1'
                    3,                      // -2 (zig-zag encoded)
@@ -376,7 +376,7 @@
 
 TEST_F(TokenizeToBuffer, C_SequentialZigZag) {
   size_t size = sizeof(buffer_);
-  pw_TokenizeToBufferTest_SequentialZigZag(buffer_, &size);
+  pw_tokenizer_ToBufferTest_SequentialZigZag(buffer_, &size);
   constexpr std::array<uint8_t, 18> expected =
       ExpectedData<0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13>(
           TEST_FORMAT_SEQUENTIAL_ZIG_ZAG);
@@ -390,7 +390,7 @@
 
   {
     size_t size = 7;
-    pw_TokenizeToBufferTest_Requires8(buffer_, &size);
+    pw_tokenizer_ToBufferTest_Requires8(buffer_, &size);
     constexpr std::array<uint8_t, 7> expected =
         ExpectedData<2, 'h', 'i'>(TEST_FORMAT_REQUIRES_8);
     ASSERT_EQ(expected.size(), size);
@@ -400,7 +400,7 @@
 
   {
     size_t size = 8;
-    pw_TokenizeToBufferTest_Requires8(buffer_, &size);
+    pw_tokenizer_ToBufferTest_Requires8(buffer_, &size);
     constexpr std::array<uint8_t, 8> expected =
         ExpectedData<2, 'h', 'i', 13>(TEST_FORMAT_REQUIRES_8);
     ASSERT_EQ(expected.size(), size);
@@ -470,7 +470,7 @@
 }
 
 TEST_F(TokenizeToCallback, C_SequentialZigZag) {
-  pw_TokenizeToCallbackTest_SequentialZigZag(SetMessage);
+  pw_tokenizer_ToCallbackTest_SequentialZigZag(SetMessage);
 
   constexpr std::array<uint8_t, 18> expected =
       ExpectedData<0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13>(
diff --git a/pw_tokenizer/tokenize_test_c.c b/pw_tokenizer/tokenize_test_c.c
index f012cb8..bf8877a 100644
--- a/pw_tokenizer/tokenize_test_c.c
+++ b/pw_tokenizer/tokenize_test_c.c
@@ -22,8 +22,8 @@
 #error "This is a test of C code and must be compiled as C, not C++."
 #endif  // __cplusplus
 
-void pw_TokenizeToBufferTest_StringShortFloat(void* buffer,
-                                              size_t* buffer_size) {
+void pw_tokenizer_ToBufferTest_StringShortFloat(void* buffer,
+                                                size_t* buffer_size) {
   char str[] = "1";
   PW_TOKENIZE_TO_BUFFER(
       buffer, buffer_size, TEST_FORMAT_STRING_SHORT_FLOAT, str, (short)-2, 3.0);
@@ -32,8 +32,8 @@
 // This test invokes the tokenization API with a variety of types. To simplify
 // validating the encoded data, numbers that are sequential when zig-zag encoded
 // are used as arguments.
-void pw_TokenizeToBufferTest_SequentialZigZag(void* buffer,
-                                              size_t* buffer_size) {
+void pw_tokenizer_ToBufferTest_SequentialZigZag(void* buffer,
+                                                size_t* buffer_size) {
   PW_TOKENIZE_TO_BUFFER(buffer,
                         buffer_size,
                         TEST_FORMAT_SEQUENTIAL_ZIG_ZAG,
@@ -53,7 +53,7 @@
                         (signed char)-7);
 }
 
-void pw_TokenizeToCallbackTest_SequentialZigZag(
+void pw_tokenizer_ToCallbackTest_SequentialZigZag(
     void (*callback)(const uint8_t* buffer, size_t size)) {
   PW_TOKENIZE_TO_CALLBACK(callback,
                           TEST_FORMAT_SEQUENTIAL_ZIG_ZAG,
@@ -73,6 +73,6 @@
                           (signed char)-7);
 }
 
-void pw_TokenizeToBufferTest_Requires8(void* buffer, size_t* buffer_size) {
+void pw_tokenizer_ToBufferTest_Requires8(void* buffer, size_t* buffer_size) {
   PW_TOKENIZE_TO_BUFFER(buffer, buffer_size, TEST_FORMAT_REQUIRES_8, "hi", -7);
 }
diff --git a/pw_tokenizer/tokenize_test_fakes.cc b/pw_tokenizer/tokenize_test_fakes.cc
index 4dcc9aa..4b9655a 100644
--- a/pw_tokenizer/tokenize_test_fakes.cc
+++ b/pw_tokenizer/tokenize_test_fakes.cc
@@ -22,14 +22,14 @@
 
 #if PW_TOKENIZER_CFG_ENABLE_TOKENIZE_TO_GLOBAL_HANDLER
 
-PW_EXTERN_C void pw_TokenizerHandleEncodedMessage(
+PW_EXTERN_C void pw_tokenizer_HandleEncodedMessage(
     const uint8_t encoded_message[], size_t size_bytes) {
   PW_UNUSED(encoded_message[0]);
   PW_UNUSED(size_bytes);
 }
 
-PW_EXTERN_C void pw_TokenizerHandleEncodedMessageWithPayload(
-    pw_TokenizerPayload payload,
+PW_EXTERN_C void pw_tokenizer_HandleEncodedMessageWithPayload(
+    pw_tokenizer_Payload payload,
     const uint8_t encoded_message[],
     size_t size_bytes) {
   PW_UNUSED(payload);
diff --git a/pw_tokenizer/tokenize_to_global_handler.cc b/pw_tokenizer/tokenize_to_global_handler.cc
index ecca3b4..da36a49 100644
--- a/pw_tokenizer/tokenize_to_global_handler.cc
+++ b/pw_tokenizer/tokenize_to_global_handler.cc
@@ -19,9 +19,9 @@
 namespace pw {
 namespace tokenizer {
 
-extern "C" void _pw_TokenizeToGlobalHandler(pw_TokenizerStringToken token,
-                                            pw_TokenizerArgTypes types,
-                                            ...) {
+extern "C" void _pw_tokenizer_ToGlobalHandler(pw_tokenizer_Token token,
+                                              _pw_tokenizer_ArgTypes types,
+                                              ...) {
   EncodedMessage encoded;
   encoded.token = token;
 
@@ -30,8 +30,8 @@
   const size_t encoded_bytes = EncodeArgs(types, args, encoded.args);
   va_end(args);
 
-  pw_TokenizerHandleEncodedMessage(reinterpret_cast<const uint8_t*>(&encoded),
-                                   sizeof(encoded.token) + encoded_bytes);
+  pw_tokenizer_HandleEncodedMessage(reinterpret_cast<const uint8_t*>(&encoded),
+                                    sizeof(encoded.token) + encoded_bytes);
 }
 
 }  // namespace tokenizer
diff --git a/pw_tokenizer/tokenize_to_global_handler_with_payload.cc b/pw_tokenizer/tokenize_to_global_handler_with_payload.cc
index b04e549..56b6520 100644
--- a/pw_tokenizer/tokenize_to_global_handler_with_payload.cc
+++ b/pw_tokenizer/tokenize_to_global_handler_with_payload.cc
@@ -19,10 +19,10 @@
 namespace pw {
 namespace tokenizer {
 
-extern "C" void _pw_TokenizeToGlobalHandlerWithPayload(
-    const pw_TokenizerPayload payload,
-    pw_TokenizerStringToken token,
-    pw_TokenizerArgTypes types,
+extern "C" void _pw_tokenizer_ToGlobalHandlerWithPayload(
+    const pw_tokenizer_Payload payload,
+    pw_tokenizer_Token token,
+    _pw_tokenizer_ArgTypes types,
     ...) {
   EncodedMessage encoded;
   encoded.token = token;
@@ -32,7 +32,7 @@
   const size_t encoded_bytes = EncodeArgs(types, args, encoded.args);
   va_end(args);
 
-  pw_TokenizerHandleEncodedMessageWithPayload(
+  pw_tokenizer_HandleEncodedMessageWithPayload(
       payload,
       reinterpret_cast<const uint8_t*>(&encoded),
       sizeof(encoded.token) + encoded_bytes);