diff --git a/src/detail/challenge-encoder.cpp b/src/detail/challenge-encoder.cpp
index 0cc98a3..41a0f8f 100644
--- a/src/detail/challenge-encoder.cpp
+++ b/src/detail/challenge-encoder.cpp
@@ -24,7 +24,7 @@
 namespace ndncert {
 
 Block
-challengeEncoder::encodeDataContent(ca::RequestState& request, const Name& issuedCertName)
+challengetlv::encodeDataContent(ca::RequestState& request, const Name& issuedCertName)
 {
   Block response(tlv::EncryptedPayload);
   response.push_back(makeNonNegativeIntegerBlock(tlv::Status, static_cast<uint64_t>(request.m_status)));
@@ -45,7 +45,7 @@
 }
 
 void
-challengeEncoder::decodeDataContent(const Block& contentBlock, requester::RequestState& state)
+challengetlv::decodeDataContent(const Block& contentBlock, requester::RequestState& state)
 {
   auto result = decodeBlockWithAesGcm128(contentBlock, state.m_aesKey.data(),
                                          state.m_requestId.data(), state.m_requestId.size());
diff --git a/src/detail/challenge-encoder.hpp b/src/detail/challenge-encoder.hpp
index 0ef68c3..0bd930c 100644
--- a/src/detail/challenge-encoder.hpp
+++ b/src/detail/challenge-encoder.hpp
@@ -26,13 +26,13 @@
 
 namespace ndn {
 namespace ndncert {
-namespace challengeEncoder {
+namespace challengetlv {
 
-  Block
-  encodeDataContent(ca::RequestState& request, const Name& issuedCertName = Name());
+Block
+encodeDataContent(ca::RequestState& request, const Name& issuedCertName = Name());
 
-  void
-  decodeDataContent(const Block& contentBlock, requester::RequestState& state);
+void
+decodeDataContent(const Block& contentBlock, requester::RequestState& state);
 
 } // namespace ChallengeEncoder
 } // namespace ndncert
diff --git a/src/detail/error-encoder.cpp b/src/detail/error-encoder.cpp
index b503f86..3fbbdc2 100644
--- a/src/detail/error-encoder.cpp
+++ b/src/detail/error-encoder.cpp
@@ -24,7 +24,7 @@
 namespace ndncert {
 
 Block
-errorEncoder::encodeDataContent(ErrorCode errorCode, const std::string& description)
+errortlv::encodeDataContent(ErrorCode errorCode, const std::string& description)
 {
   Block response(ndn::tlv::Content);
   response.push_back(makeNonNegativeIntegerBlock(tlv::ErrorCode, static_cast<size_t>(errorCode)));
@@ -34,7 +34,7 @@
 }
 
 std::tuple<ErrorCode, std::string>
-errorEncoder::decodefromDataContent(const Block& block)
+errortlv::decodefromDataContent(const Block& block)
 {
   block.parse();
   if (block.find(tlv::ErrorCode) == block.elements_end()) {
diff --git a/src/detail/error-encoder.hpp b/src/detail/error-encoder.hpp
index d8f6ea4..650dd11 100644
--- a/src/detail/error-encoder.hpp
+++ b/src/detail/error-encoder.hpp
@@ -25,22 +25,22 @@
 
 namespace ndn {
 namespace ndncert {
-namespace errorEncoder {
+namespace errortlv {
 
-  /**
-   * Encode error information into a Data content TLV
-   */
-  Block
-  encodeDataContent(ErrorCode errorCode, const std::string& description);
+/**
+ * Encode error information into a Data content TLV
+ */
+Block
+encodeDataContent(ErrorCode errorCode, const std::string& description);
 
-  /**
-   * Decode error information from Data content TLV
-   */
-  std::tuple<ErrorCode, std::string>
-  decodefromDataContent(const Block& block);
+/**
+ * Decode error information from Data content TLV
+ */
+std::tuple<ErrorCode, std::string>
+decodefromDataContent(const Block& block);
 
-} // namespace ErrorEncoder
-} // namespace ndncert
-} // namespace ndn
+}  // namespace errortlv
+}  // namespace ndncert
+}  // namespace ndn
 
-#endif // NDNCERT_DETAIL_ERROR_ENCODER_HPP
\ No newline at end of file
+#endif  // NDNCERT_DETAIL_ERROR_ENCODER_HPP
\ No newline at end of file
diff --git a/src/detail/info-encoder.cpp b/src/detail/info-encoder.cpp
index 746aafc..17e798c 100644
--- a/src/detail/info-encoder.cpp
+++ b/src/detail/info-encoder.cpp
@@ -24,7 +24,7 @@
 namespace ndncert {
 
 Block
-infoEncoder::encodeDataContent(const CaProfile& caConfig, const security::Certificate& certificate)
+infotlv::encodeDataContent(const CaProfile& caConfig, const security::Certificate& certificate)
 {
   Block content(ndn::tlv::Content);
   content.push_back(makeNestedBlock(tlv::CaPrefix, caConfig.m_caPrefix));
@@ -46,7 +46,7 @@
 }
 
 CaProfile
-infoEncoder::decodeDataContent(const Block& block)
+infotlv::decodeDataContent(const Block& block)
 {
   CaProfile result;
   block.parse();
diff --git a/src/detail/info-encoder.hpp b/src/detail/info-encoder.hpp
index 48a1d82..ae5348e 100644
--- a/src/detail/info-encoder.hpp
+++ b/src/detail/info-encoder.hpp
@@ -25,18 +25,19 @@
 
 namespace ndn {
 namespace ndncert {
-namespace infoEncoder {
-  /**
-   * Encode CA configuration and its certificate into a TLV block as INFO Data packet content.
-   */
-  Block
-  encodeDataContent(const CaProfile& caConfig, const security::Certificate& certificate);
+namespace infotlv {
 
-  /**
-   * Decode CA configuration from the TLV block of INFO Data packet content.
-   */
-  CaProfile
-  decodeDataContent(const Block& block);
+/**
+ * Encode CA configuration and its certificate into a TLV block as INFO Data packet content.
+ */
+Block
+encodeDataContent(const CaProfile& caConfig, const security::Certificate& certificate);
+
+/**
+ * Decode CA configuration from the TLV block of INFO Data packet content.
+ */
+CaProfile
+decodeDataContent(const Block& block);
 
 } // namespace InfoEncoder
 } // namespace ndncert
diff --git a/src/detail/new-renew-revoke-encoder.cpp b/src/detail/new-renew-revoke-encoder.cpp
index bdde1cf..fa4626c 100644
--- a/src/detail/new-renew-revoke-encoder.cpp
+++ b/src/detail/new-renew-revoke-encoder.cpp
@@ -29,7 +29,7 @@
 NDN_LOG_INIT(ndncert.encoding.new_renew_revoke);
 
 Block
-newRenewRevokeEncoder::encodeApplicationParameters(RequestType requestType, const std::vector<uint8_t>& ecdhPub,
+requesttlv::encodeApplicationParameters(RequestType requestType, const std::vector<uint8_t>& ecdhPub,
                                                    const security::Certificate& certRequest)
 {
   Block request(ndn::tlv::ApplicationParameters);
@@ -56,7 +56,7 @@
 }
 
 void
-newRenewRevokeEncoder::decodeApplicationParameters(const Block& payload, RequestType requestType,
+requesttlv::decodeApplicationParameters(const Block& payload, RequestType requestType,
                                                    std::vector<uint8_t>& ecdhPub,
                                                    shared_ptr<security::Certificate>& clientCert)
 {
@@ -80,7 +80,7 @@
 }
 
 Block
-newRenewRevokeEncoder::encodeDataContent(const std::vector<uint8_t>& ecdhKey, const std::array<uint8_t, 32>& salt,
+requesttlv::encodeDataContent(const std::vector<uint8_t>& ecdhKey, const std::array<uint8_t, 32>& salt,
                                          const RequestId& requestId, const Status& status,
                                          const std::list<std::string>& challenges)
 {
@@ -97,7 +97,7 @@
 }
 
 std::list<std::string>
-newRenewRevokeEncoder::decodeDataContent(const Block& content, std::vector<uint8_t>& ecdhKey,
+requesttlv::decodeDataContent(const Block& content, std::vector<uint8_t>& ecdhKey,
                                          std::array<uint8_t, 32>& salt, RequestId& requestId, Status& status)
 {
   content.parse();
diff --git a/src/detail/new-renew-revoke-encoder.hpp b/src/detail/new-renew-revoke-encoder.hpp
index c70404c..563e562 100644
--- a/src/detail/new-renew-revoke-encoder.hpp
+++ b/src/detail/new-renew-revoke-encoder.hpp
@@ -25,26 +25,26 @@
 
 namespace ndn {
 namespace ndncert {
-namespace newRenewRevokeEncoder {
+namespace requesttlv {
 
-  Block
-  encodeApplicationParameters(RequestType requestType, const std::vector<uint8_t>& ecdhPub,
-                              const security::Certificate& certRequest);
+Block
+encodeApplicationParameters(RequestType requestType, const std::vector<uint8_t>& ecdhPub,
+                            const security::Certificate& certRequest);
 
-  void
-  decodeApplicationParameters(const Block& block, RequestType requestType, std::vector<uint8_t>& ecdhPub,
-                              shared_ptr<security::Certificate>& certRequest);
+void
+decodeApplicationParameters(const Block& block, RequestType requestType, std::vector<uint8_t>& ecdhPub,
+                            shared_ptr<security::Certificate>& certRequest);
 
-  Block
-  encodeDataContent(const std::vector<uint8_t>& ecdhKey, const std::array<uint8_t, 32>& salt,
-                    const RequestId& requestId, const Status& status,
-                    const std::list<std::string>& challenges);
+Block
+encodeDataContent(const std::vector<uint8_t>& ecdhKey, const std::array<uint8_t, 32>& salt,
+                  const RequestId& requestId, const Status& status,
+                  const std::list<std::string>& challenges);
 
-  std::list<std::string>
-  decodeDataContent(const Block& content, std::vector<uint8_t>& ecdhKey,
-                    std::array<uint8_t, 32>& salt, RequestId& requestId, Status& status);
+std::list<std::string>
+decodeDataContent(const Block& content, std::vector<uint8_t>& ecdhKey,
+                  std::array<uint8_t, 32>& salt, RequestId& requestId, Status& status);
 
-} // namespace NewRenewRevokeEncoder
+} // namespace requesttlv
 } // namespace ndncert
 } // namespace ndn
 
diff --git a/src/detail/probe-encoder.cpp b/src/detail/probe-encoder.cpp
index f040d2e..e8f5218 100644
--- a/src/detail/probe-encoder.cpp
+++ b/src/detail/probe-encoder.cpp
@@ -24,7 +24,7 @@
 namespace ndncert {
 
 Block
-probeEncoder::encodeApplicationParameters(std::multimap<std::string, std::string>&& parameters)
+probetlv::encodeApplicationParameters(std::multimap<std::string, std::string>&& parameters)
 {
   Block content(ndn::tlv::ApplicationParameters);
   for (const auto& items : parameters) {
@@ -36,7 +36,7 @@
 }
 
 std::multimap<std::string, std::string>
-probeEncoder::decodeApplicationParameters(const Block& block)
+probetlv::decodeApplicationParameters(const Block& block)
 {
   std::multimap<std::string, std::string> result;
   block.parse();
@@ -50,7 +50,7 @@
 }
 
 Block
-probeEncoder::encodeDataContent(const std::vector<Name>& identifiers, optional<size_t> maxSuffixLength,
+probetlv::encodeDataContent(const std::vector<Name>& identifiers, optional<size_t> maxSuffixLength,
                                 optional<std::vector<std::shared_ptr<security::Certificate>>> redirectionItems)
 {
   Block content(ndn::tlv::Content);
@@ -72,7 +72,7 @@
 }
 
 void
-probeEncoder::decodeDataContent(const Block& block,
+probetlv::decodeDataContent(const Block& block,
                                 std::vector<std::pair<Name, int>>& availableNames,
                                 std::vector<Name>& availableRedirection)
 {
diff --git a/src/detail/probe-encoder.hpp b/src/detail/probe-encoder.hpp
index 3985f93..a7b212a 100644
--- a/src/detail/probe-encoder.hpp
+++ b/src/detail/probe-encoder.hpp
@@ -25,24 +25,25 @@
 
 namespace ndn {
 namespace ndncert {
-namespace probeEncoder {
+namespace probetlv {
 
-  // For Client use
-  Block
-  encodeApplicationParameters(std::multimap<std::string, std::string>&& parameters);
+// For Client use
+Block
+encodeApplicationParameters(std::multimap<std::string, std::string>&& parameters);
 
-  void
-  decodeDataContent(const Block& block, std::vector<std::pair<Name, int>>& availableNames,
-                    std::vector<Name>& availableRedirection);
+void
+decodeDataContent(const Block& block, std::vector<std::pair<Name, int>>& availableNames,
+                  std::vector<Name>& availableRedirection);
 
-  // For CA use
-  Block
-  encodeDataContent(const std::vector<Name>& identifiers,
-                    optional<size_t> maxSuffixLength = nullopt,
-                    optional<std::vector<std::shared_ptr<security::Certificate>>> redirectionItems = nullopt);
+// For CA use
+Block
+encodeDataContent(const std::vector<Name>& identifiers,
+                  optional<size_t> maxSuffixLength = nullopt,
+                  optional<std::vector<std::shared_ptr<security::Certificate>>> redirectionItems = nullopt);
 
-  std::multimap<std::string, std::string>
-  decodeApplicationParameters(const Block& block);
+std::multimap<std::string, std::string>
+decodeApplicationParameters(const Block& block);
+
 } // namespace ProbeEncoder
 } // namespace ndncert
 } // namespace ndn