diff --git a/CHANGELOG.md b/CHANGELOG.md
index 766ec78..4fc9dea 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,13 @@
 ### Breaking changes
 - Removed deprecated `Packaging` enum and `packaging` field that's no longer supported
   by the API
+- Renamed `VersionUpgradePolicy::Upgrade` to `UpgradeToV2` in preparation for a future
+  DBN version 3
+
+### Enhancements
+- Created separate namespaces for each DBN version to create a consistent way to refer
+  to record types from a particular DBN version regardless of whether the record changed
+  between versions
 
 ## 0.25.0 - 2024-11-12
 
diff --git a/cmake/SourcesAndHeaders.cmake b/cmake/SourcesAndHeaders.cmake
index 4436e03..3f1fd92 100644
--- a/cmake/SourcesAndHeaders.cmake
+++ b/cmake/SourcesAndHeaders.cmake
@@ -31,13 +31,14 @@ set(headers
   include/databento/symbol_map.hpp
   include/databento/symbology.hpp
   include/databento/timeseries.hpp
+  include/databento/v1.hpp
+  include/databento/v2.hpp
   include/databento/with_ts_out.hpp
   src/stream_op_helper.hpp
 )
 
 set(sources
   src/batch.cpp
-  src/compat.cpp
   src/datetime.cpp
   src/dbn.cpp
   src/dbn_constants.hpp
@@ -65,4 +66,5 @@ set(sources
   src/record.cpp
   src/symbol_map.cpp
   src/symbology.cpp
+  src/v1.cpp
 )
diff --git a/include/databento/compat.hpp b/include/databento/compat.hpp
index a79eab3..a3e6a10 100644
--- a/include/databento/compat.hpp
+++ b/include/databento/compat.hpp
@@ -4,201 +4,24 @@
 #include <cstddef>  // size_t
 #include <cstdint>
 
-#include "databento/constants.hpp"  // kSymbolCstrLen
-#include "databento/datetime.hpp"   // UnixNanos
-#include "databento/enums.hpp"
-#include "databento/record.hpp"
+#include "databento/v1.hpp"
+#include "databento/v2.hpp"
 
 namespace databento {
-static constexpr std::size_t kSymbolCstrLenV1 = 22;
-static constexpr std::size_t kSymbolCstrLenV2 = kSymbolCstrLen;
+static constexpr std::size_t kSymbolCstrLenV1 = v1::kSymbolCstrLen;
+static constexpr std::size_t kSymbolCstrLenV2 = v2::kSymbolCstrLen;
 
 constexpr std::size_t VersionSymbolCstrLen(std::uint8_t version) {
   return version < 2 ? kSymbolCstrLenV1 : kSymbolCstrLenV2;
 }
 
-using InstrumentDefMsgV2 = InstrumentDefMsg;
-using ErrorMsgV2 = ErrorMsg;
-using SymbolMappingMsgV2 = SymbolMappingMsg;
-using SystemMsgV2 = SystemMsg;
-
+using InstrumentDefMsgV1 = v1::InstrumentDefMsg;
+using InstrumentDefMsgV2 = v2::InstrumentDefMsg;
+using ErrorMsgV1 = v1::ErrorMsg;
+using ErrorMsgV2 = v2::ErrorMsg;
+using SymbolMappingMsgV1 = v1::SymbolMappingMsg;
+using SymbolMappingMsgV2 = v2::SymbolMappingMsg;
+using SystemMsgV1 = v1::SystemMsg;
+using SystemMsgV2 = v2::SystemMsg;
 // DBN version 1 instrument definition.
-struct InstrumentDefMsgV1 {
-  static bool HasRType(RType rtype) { return rtype == RType::InstrumentDef; }
-
-  InstrumentDefMsgV2 ToV2() const;
-  const char* Currency() const { return currency.data(); }
-  const char* SettlCurrency() const { return settl_currency.data(); }
-  const char* SecSubType() const { return secsubtype.data(); }
-  const char* RawSymbol() const { return raw_symbol.data(); }
-  const char* Group() const { return group.data(); }
-  const char* Exchange() const { return exchange.data(); }
-  const char* Asset() const { return asset.data(); }
-  const char* Cfi() const { return cfi.data(); }
-  const char* SecurityType() const { return security_type.data(); }
-  const char* UnitOfMeasure() const { return unit_of_measure.data(); }
-  const char* Underlying() const { return underlying.data(); }
-  const char* StrikePriceCurrency() const {
-    return strike_price_currency.data();
-  }
-
-  RecordHeader hd;
-  UnixNanos ts_recv;
-  std::int64_t min_price_increment;
-  std::int64_t display_factor;
-  UnixNanos expiration;
-  UnixNanos activation;
-  std::int64_t high_limit_price;
-  std::int64_t low_limit_price;
-  std::int64_t max_price_variation;
-  std::int64_t trading_reference_price;
-  std::int64_t unit_of_measure_qty;
-  std::int64_t min_price_increment_amount;
-  std::int64_t price_ratio;
-  std::int32_t inst_attrib_value;
-  std::uint32_t underlying_id;
-  std::uint32_t raw_instrument_id;
-  std::int32_t market_depth_implied;
-  std::int32_t market_depth;
-  std::uint32_t market_segment_id;
-  std::uint32_t max_trade_vol;
-  std::int32_t min_lot_size;
-  std::int32_t min_lot_size_block;
-  std::int32_t min_lot_size_round_lot;
-  std::uint32_t min_trade_vol;
-  std::array<char, 4> _reserved2;
-  std::int32_t contract_multiplier;
-  std::int32_t decay_quantity;
-  std::int32_t original_contract_size;
-  std::array<char, 4> _reserved3;
-  std::uint16_t trading_reference_date;
-  std::int16_t appl_id;
-  std::uint16_t maturity_year;
-  std::uint16_t decay_start_date;
-  std::uint16_t channel_id;
-  std::array<char, 4> currency;
-  std::array<char, 4> settl_currency;
-  std::array<char, 6> secsubtype;
-  std::array<char, kSymbolCstrLenV1> raw_symbol;
-  std::array<char, 21> group;
-  std::array<char, 5> exchange;
-  std::array<char, 7> asset;
-  std::array<char, 7> cfi;
-  std::array<char, 7> security_type;
-  std::array<char, 31> unit_of_measure;
-  std::array<char, 21> underlying;
-  std::array<char, 4> strike_price_currency;
-  InstrumentClass instrument_class;
-  std::array<char, 2> _reserved4;
-  std::int64_t strike_price;
-  std::array<char, 6> _reserved5;
-  MatchAlgorithm match_algorithm;
-  std::uint8_t md_security_trading_status;
-  std::uint8_t main_fraction;
-  std::uint8_t price_display_format;
-  std::uint8_t settl_price_type;
-  std::uint8_t sub_fraction;
-  std::uint8_t underlying_product;
-  SecurityUpdateAction security_update_action;
-  std::uint8_t maturity_month;
-  std::uint8_t maturity_day;
-  std::uint8_t maturity_week;
-  UserDefinedInstrument user_defined_instrument;
-  std::int8_t contract_multiplier_unit;
-  std::int8_t flow_schedule_type;
-  std::uint8_t tick_rule;
-  // padding for alignment
-  std::array<char, 3> dummy;
-};
-static_assert(sizeof(InstrumentDefMsgV1) == 360, "Size must match Rust");
-static_assert(alignof(InstrumentDefMsgV1) == 8, "Must have 8-byte alignment");
-
-// An error message from the Live Subscription Gateway (LSG). This will never
-// be present in historical data.
-struct ErrorMsgV1 {
-  static bool HasRType(RType rtype) { return rtype == RType::Error; }
-
-  ErrorMsgV2 ToV2() const;
-  UnixNanos IndexTs() const { return hd.ts_event; }
-  const char* Err() const { return err.data(); }
-
-  RecordHeader hd;
-  std::array<char, 64> err;
-};
-static_assert(sizeof(ErrorMsgV1) == 80, "ErrorMsg size must match Rust");
-static_assert(alignof(ErrorMsgV1) == 8, "Must have 8-byte alignment");
-
-/// A symbol mapping message.
-struct SymbolMappingMsgV1 {
-  static bool HasRType(RType rtype) { return rtype == RType::SymbolMapping; }
-
-  SymbolMappingMsgV2 ToV2() const;
-  const char* STypeInSymbol() const { return stype_in_symbol.data(); }
-  const char* STypeOutSymbol() const { return stype_out_symbol.data(); }
-
-  RecordHeader hd;
-  std::array<char, kSymbolCstrLenV1> stype_in_symbol;
-  std::array<char, kSymbolCstrLenV1> stype_out_symbol;
-  // padding for alignment
-  std::array<char, 4> dummy;
-  UnixNanos start_ts;
-  UnixNanos end_ts;
-};
-static_assert(sizeof(SymbolMappingMsgV1) == 80, "Size must match Rust");
-static_assert(alignof(SymbolMappingMsgV1) == 8, "Must have 8-byte alignment");
-
-struct SystemMsgV1 {
-  static bool HasRType(RType rtype) { return rtype == RType::System; }
-
-  SystemMsgV2 ToV2() const;
-  UnixNanos IndexTs() const { return hd.ts_event; }
-  const char* Msg() const { return msg.data(); }
-  bool IsHeartbeat() const {
-    return std::strncmp(msg.data(), "Heartbeat", 9) == 0;
-  }
-
-  RecordHeader hd;
-  std::array<char, 64> msg;
-};
-static_assert(sizeof(SystemMsgV1) == 80, "SystemMsg size must match Rust");
-static_assert(alignof(SystemMsgV1) == 8, "Must have 8-byte alignment");
-
-bool operator==(const InstrumentDefMsgV1& lhs, const InstrumentDefMsgV1& rhs);
-inline bool operator!=(const InstrumentDefMsgV1& lhs,
-                       const InstrumentDefMsgV1& rhs) {
-  return !(lhs == rhs);
-}
-inline bool operator==(const ErrorMsgV1& lhs, const ErrorMsgV1& rhs) {
-  return std::tie(lhs.hd, lhs.err) == std::tie(rhs.hd, rhs.err);
-}
-inline bool operator!=(const ErrorMsgV1& lhs, const ErrorMsgV1& rhs) {
-  return !(lhs == rhs);
-}
-inline bool operator==(const SymbolMappingMsgV1& lhs,
-                       const SymbolMappingMsgV1& rhs) {
-  return std::tie(lhs.hd, lhs.stype_in_symbol, lhs.stype_out_symbol,
-                  lhs.start_ts, lhs.end_ts) ==
-         std::tie(rhs.hd, rhs.stype_in_symbol, rhs.stype_out_symbol,
-                  rhs.start_ts, rhs.end_ts);
-}
-inline bool operator!=(const SymbolMappingMsgV1& lhs,
-                       const SymbolMappingMsgV1& rhs) {
-  return !(lhs == rhs);
-}
-inline bool operator==(const SystemMsgV1& lhs, const SystemMsgV1& rhs) {
-  return std::tie(lhs.hd, lhs.msg) == std::tie(rhs.hd, rhs.msg);
-}
-inline bool operator!=(const SystemMsgV1& lhs, const SystemMsgV1& rhs) {
-  return !(lhs == rhs);
-}
-std::string ToString(const InstrumentDefMsgV1& instr_def_msg);
-std::ostream& operator<<(std::ostream& stream,
-                         const InstrumentDefMsgV1& instr_def_msg);
-std::string ToString(const ErrorMsgV1& err_msg);
-std::ostream& operator<<(std::ostream& stream, const ErrorMsgV1& err_msg);
-std::string ToString(const SymbolMappingMsgV1& symbol_mapping_msg);
-std::ostream& operator<<(std::ostream& stream,
-                         const SymbolMappingMsgV1& symbol_mapping_msg);
-std::string ToString(const SystemMsgV1& sys_msg);
-std::ostream& operator<<(std::ostream& stream, const SystemMsgV1& sys_msg);
 }  // namespace databento
diff --git a/include/databento/enums.hpp b/include/databento/enums.hpp
index b80a4a5..8dea2bb 100644
--- a/include/databento/enums.hpp
+++ b/include/databento/enums.hpp
@@ -297,7 +297,7 @@ enum class StatUpdateAction : std::uint8_t {
 // How to handle decoding DBN data from a prior version.
 enum class VersionUpgradePolicy : std::uint8_t {
   AsIs = 0,
-  Upgrade = 1,
+  UpgradeToV2 = 1,
 };
 
 namespace status_action {
diff --git a/include/databento/live.hpp b/include/databento/live.hpp
index c0f5352..ca498c4 100644
--- a/include/databento/live.hpp
+++ b/include/databento/live.hpp
@@ -52,7 +52,7 @@ class LiveBuilder {
   std::string key_;
   std::string dataset_;
   bool send_ts_out_{false};
-  VersionUpgradePolicy upgrade_policy_{VersionUpgradePolicy::Upgrade};
+  VersionUpgradePolicy upgrade_policy_{VersionUpgradePolicy::UpgradeToV2};
   std::chrono::seconds heartbeat_interval_{};
 };
 }  // namespace databento
diff --git a/include/databento/v1.hpp b/include/databento/v1.hpp
new file mode 100644
index 0000000..bdd3865
--- /dev/null
+++ b/include/databento/v1.hpp
@@ -0,0 +1,209 @@
+#pragma once
+
+#include "databento/datetime.hpp"  // UnixNanos
+#include "databento/enums.hpp"
+#include "databento/record.hpp"
+#include "databento/v2.hpp"
+
+namespace databento {
+namespace v1 {
+static constexpr std::size_t kSymbolCstrLen = 22;
+
+using MboMsg = databento::MboMsg;
+using TradeMsg = databento::TradeMsg;
+using Mbp1Msg = databento::Mbp1Msg;
+using TbboMsg = databento::TbboMsg;
+using Mbp10Msg = databento::Mbp10Msg;
+using BboMsg = databento::BboMsg;
+using Bbo1SMsg = databento::Bbo1SMsg;
+using Bbo1MMsg = databento::Bbo1MMsg;
+using Cmbp1Msg = databento::Cmbp1Msg;
+using TcbboMsg = databento::TcbboMsg;
+using CbboMsg = databento::CbboMsg;
+using Cbbo1SMsg = databento::Cbbo1SMsg;
+using Cbbo1MMsg = databento::Cbbo1MMsg;
+using OhlcvMsg = databento::OhlcvMsg;
+using StatusMsg = databento::StatusMsg;
+using ImbalanceMsg = databento::ImbalanceMsg;
+using StatMsg = databento::StatMsg;
+
+struct InstrumentDefMsg {
+  static bool HasRType(RType rtype) { return rtype == RType::InstrumentDef; }
+
+  v2::InstrumentDefMsg ToV2() const;
+  const char* Currency() const { return currency.data(); }
+  const char* SettlCurrency() const { return settl_currency.data(); }
+  const char* SecSubType() const { return secsubtype.data(); }
+  const char* RawSymbol() const { return raw_symbol.data(); }
+  const char* Group() const { return group.data(); }
+  const char* Exchange() const { return exchange.data(); }
+  const char* Asset() const { return asset.data(); }
+  const char* Cfi() const { return cfi.data(); }
+  const char* SecurityType() const { return security_type.data(); }
+  const char* UnitOfMeasure() const { return unit_of_measure.data(); }
+  const char* Underlying() const { return underlying.data(); }
+  const char* StrikePriceCurrency() const {
+    return strike_price_currency.data();
+  }
+
+  RecordHeader hd;
+  UnixNanos ts_recv;
+  std::int64_t min_price_increment;
+  std::int64_t display_factor;
+  UnixNanos expiration;
+  UnixNanos activation;
+  std::int64_t high_limit_price;
+  std::int64_t low_limit_price;
+  std::int64_t max_price_variation;
+  std::int64_t trading_reference_price;
+  std::int64_t unit_of_measure_qty;
+  std::int64_t min_price_increment_amount;
+  std::int64_t price_ratio;
+  std::int32_t inst_attrib_value;
+  std::uint32_t underlying_id;
+  std::uint32_t raw_instrument_id;
+  std::int32_t market_depth_implied;
+  std::int32_t market_depth;
+  std::uint32_t market_segment_id;
+  std::uint32_t max_trade_vol;
+  std::int32_t min_lot_size;
+  std::int32_t min_lot_size_block;
+  std::int32_t min_lot_size_round_lot;
+  std::uint32_t min_trade_vol;
+  std::array<char, 4> _reserved2;
+  std::int32_t contract_multiplier;
+  std::int32_t decay_quantity;
+  std::int32_t original_contract_size;
+  std::array<char, 4> _reserved3;
+  std::uint16_t trading_reference_date;
+  std::int16_t appl_id;
+  std::uint16_t maturity_year;
+  std::uint16_t decay_start_date;
+  std::uint16_t channel_id;
+  std::array<char, 4> currency;
+  std::array<char, 4> settl_currency;
+  std::array<char, 6> secsubtype;
+  std::array<char, kSymbolCstrLen> raw_symbol;
+  std::array<char, 21> group;
+  std::array<char, 5> exchange;
+  std::array<char, 7> asset;
+  std::array<char, 7> cfi;
+  std::array<char, 7> security_type;
+  std::array<char, 31> unit_of_measure;
+  std::array<char, 21> underlying;
+  std::array<char, 4> strike_price_currency;
+  InstrumentClass instrument_class;
+  std::array<char, 2> _reserved4;
+  std::int64_t strike_price;
+  std::array<char, 6> _reserved5;
+  MatchAlgorithm match_algorithm;
+  std::uint8_t md_security_trading_status;
+  std::uint8_t main_fraction;
+  std::uint8_t price_display_format;
+  std::uint8_t settl_price_type;
+  std::uint8_t sub_fraction;
+  std::uint8_t underlying_product;
+  SecurityUpdateAction security_update_action;
+  std::uint8_t maturity_month;
+  std::uint8_t maturity_day;
+  std::uint8_t maturity_week;
+  UserDefinedInstrument user_defined_instrument;
+  std::int8_t contract_multiplier_unit;
+  std::int8_t flow_schedule_type;
+  std::uint8_t tick_rule;
+  // padding for alignment
+  std::array<char, 3> dummy;
+};
+static_assert(sizeof(InstrumentDefMsg) == 360, "Size must match Rust");
+static_assert(alignof(InstrumentDefMsg) == 8, "Must have 8-byte alignment");
+
+// An error message from the Live Subscription Gateway (LSG). This will never
+// be present in historical data.
+struct ErrorMsg {
+  static bool HasRType(RType rtype) { return rtype == RType::Error; }
+
+  v2::ErrorMsg ToV2() const;
+  UnixNanos IndexTs() const { return hd.ts_event; }
+  const char* Err() const { return err.data(); }
+
+  RecordHeader hd;
+  std::array<char, 64> err;
+};
+static_assert(sizeof(ErrorMsg) == 80, "ErrorMsg size must match Rust");
+static_assert(alignof(ErrorMsg) == 8, "Must have 8-byte alignment");
+
+/// A symbol mapping message.
+struct SymbolMappingMsg {
+  static bool HasRType(RType rtype) { return rtype == RType::SymbolMapping; }
+
+  v2::SymbolMappingMsg ToV2() const;
+  const char* STypeInSymbol() const { return stype_in_symbol.data(); }
+  const char* STypeOutSymbol() const { return stype_out_symbol.data(); }
+
+  RecordHeader hd;
+  std::array<char, kSymbolCstrLen> stype_in_symbol;
+  std::array<char, kSymbolCstrLen> stype_out_symbol;
+  // padding for alignment
+  std::array<char, 4> dummy;
+  UnixNanos start_ts;
+  UnixNanos end_ts;
+};
+static_assert(sizeof(SymbolMappingMsg) == 80, "Size must match Rust");
+static_assert(alignof(SymbolMappingMsg) == 8, "Must have 8-byte alignment");
+
+struct SystemMsg {
+  static bool HasRType(RType rtype) { return rtype == RType::System; }
+
+  v2::SystemMsg ToV2() const;
+  UnixNanos IndexTs() const { return hd.ts_event; }
+  const char* Msg() const { return msg.data(); }
+  bool IsHeartbeat() const {
+    return std::strncmp(msg.data(), "Heartbeat", 9) == 0;
+  }
+
+  RecordHeader hd;
+  std::array<char, 64> msg;
+};
+static_assert(sizeof(SystemMsg) == 80, "SystemMsg size must match Rust");
+static_assert(alignof(SystemMsg) == 8, "Must have 8-byte alignment");
+
+bool operator==(const InstrumentDefMsg& lhs, const InstrumentDefMsg& rhs);
+inline bool operator!=(const InstrumentDefMsg& lhs,
+                       const InstrumentDefMsg& rhs) {
+  return !(lhs == rhs);
+}
+inline bool operator==(const ErrorMsg& lhs, const ErrorMsg& rhs) {
+  return std::tie(lhs.hd, lhs.err) == std::tie(rhs.hd, rhs.err);
+}
+inline bool operator!=(const ErrorMsg& lhs, const ErrorMsg& rhs) {
+  return !(lhs == rhs);
+}
+inline bool operator==(const SymbolMappingMsg& lhs,
+                       const SymbolMappingMsg& rhs) {
+  return std::tie(lhs.hd, lhs.stype_in_symbol, lhs.stype_out_symbol,
+                  lhs.start_ts, lhs.end_ts) ==
+         std::tie(rhs.hd, rhs.stype_in_symbol, rhs.stype_out_symbol,
+                  rhs.start_ts, rhs.end_ts);
+}
+inline bool operator!=(const SymbolMappingMsg& lhs,
+                       const SymbolMappingMsg& rhs) {
+  return !(lhs == rhs);
+}
+inline bool operator==(const SystemMsg& lhs, const SystemMsg& rhs) {
+  return std::tie(lhs.hd, lhs.msg) == std::tie(rhs.hd, rhs.msg);
+}
+inline bool operator!=(const SystemMsg& lhs, const SystemMsg& rhs) {
+  return !(lhs == rhs);
+}
+std::string ToString(const InstrumentDefMsg& instr_def_msg);
+std::ostream& operator<<(std::ostream& stream,
+                         const InstrumentDefMsg& instr_def_msg);
+std::string ToString(const ErrorMsg& err_msg);
+std::ostream& operator<<(std::ostream& stream, const ErrorMsg& err_msg);
+std::string ToString(const SymbolMappingMsg& symbol_mapping_msg);
+std::ostream& operator<<(std::ostream& stream,
+                         const SymbolMappingMsg& symbol_mapping_msg);
+std::string ToString(const SystemMsg& sys_msg);
+std::ostream& operator<<(std::ostream& stream, const SystemMsg& sys_msg);
+}  // namespace v1
+}  // namespace databento
diff --git a/include/databento/v2.hpp b/include/databento/v2.hpp
new file mode 100644
index 0000000..c303f23
--- /dev/null
+++ b/include/databento/v2.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "databento/constants.hpp"  // kSymbolCstrLen
+#include "databento/record.hpp"
+
+namespace databento {
+namespace v2 {
+static constexpr std::size_t kSymbolCstrLen = databento::kSymbolCstrLen;
+
+using MboMsg = databento::MboMsg;
+using TradeMsg = databento::TradeMsg;
+using Mbp1Msg = databento::Mbp1Msg;
+using TbboMsg = databento::TbboMsg;
+using Mbp10Msg = databento::Mbp10Msg;
+using BboMsg = databento::BboMsg;
+using Bbo1SMsg = databento::Bbo1SMsg;
+using Bbo1MMsg = databento::Bbo1MMsg;
+using Cmbp1Msg = databento::Cmbp1Msg;
+using TcbboMsg = databento::TcbboMsg;
+using CbboMsg = databento::CbboMsg;
+using Cbbo1SMsg = databento::Cbbo1SMsg;
+using Cbbo1MMsg = databento::Cbbo1MMsg;
+using OhlcvMsg = databento::OhlcvMsg;
+using StatusMsg = databento::StatusMsg;
+using InstrumentDefMsg = databento::InstrumentDefMsg;
+using ImbalanceMsg = databento::ImbalanceMsg;
+using StatMsg = databento::StatMsg;
+using ErrorMsg = databento::ErrorMsg;
+using SymbolMappingMsg = databento::SymbolMappingMsg;
+using SystemMsg = databento::SystemMsg;
+}  // namespace v2
+}  // namespace databento
diff --git a/src/dbn.cpp b/src/dbn.cpp
index ad7af28..070c8a2 100644
--- a/src/dbn.cpp
+++ b/src/dbn.cpp
@@ -17,7 +17,7 @@ TsSymbolMap Metadata::CreateSymbolMap() const { return TsSymbolMap{*this}; }
 
 void Metadata::Upgrade(VersionUpgradePolicy upgrade_policy) {
   if (version < kDbnVersion &&
-      upgrade_policy == VersionUpgradePolicy::Upgrade) {
+      upgrade_policy == VersionUpgradePolicy::UpgradeToV2) {
     version = kDbnVersion;
     symbol_cstr_len = kSymbolCstrLen;
   }
diff --git a/src/dbn_decoder.cpp b/src/dbn_decoder.cpp
index 27a2021..d2eb1c2 100644
--- a/src/dbn_decoder.cpp
+++ b/src/dbn_decoder.cpp
@@ -75,7 +75,7 @@ DbnDecoder::DbnDecoder(ILogReceiver* log_receiver, InFileStream file_stream)
 DbnDecoder::DbnDecoder(ILogReceiver* log_receiver,
                        std::unique_ptr<IReadable> input)
     : DbnDecoder(log_receiver, std::move(input),
-                 VersionUpgradePolicy::Upgrade) {}
+                 VersionUpgradePolicy::UpgradeToV2) {}
 
 DbnDecoder::DbnDecoder(ILogReceiver* log_receiver,
                        std::unique_ptr<IReadable> input,
@@ -228,7 +228,7 @@ databento::Record UpgradeRecord(
 databento::Record DbnDecoder::DecodeRecordCompat(
     std::uint8_t version, VersionUpgradePolicy upgrade_policy, bool ts_out,
     std::array<std::uint8_t, kMaxRecordLen>* compat_buffer, Record rec) {
-  if (version == 1 && upgrade_policy == VersionUpgradePolicy::Upgrade) {
+  if (version == 1 && upgrade_policy == VersionUpgradePolicy::UpgradeToV2) {
     if (rec.RType() == RType::InstrumentDef) {
       return UpgradeRecord<InstrumentDefMsgV1, InstrumentDefMsgV2>(
           ts_out, compat_buffer, rec);
diff --git a/src/enums.cpp b/src/enums.cpp
index 475e805..8a034d6 100644
--- a/src/enums.cpp
+++ b/src/enums.cpp
@@ -748,7 +748,7 @@ const char* ToString(VersionUpgradePolicy upgrade_policy) {
     case VersionUpgradePolicy::AsIs: {
       return "AsIs";
     }
-    case VersionUpgradePolicy::Upgrade: {
+    case VersionUpgradePolicy::UpgradeToV2: {
       return "Upgrade";
     }
     default: {
diff --git a/src/historical.cpp b/src/historical.cpp
index 4e7df61..ffcc312 100644
--- a/src/historical.cpp
+++ b/src/historical.cpp
@@ -974,7 +974,8 @@ databento::DbnFileStore Historical::TimeseriesGetRangeToFile(
 databento::DbnFileStore Historical::TimeseriesGetRangeToFile(
     const HttplibParams& params, const std::string& file_path) {
   StreamToFile(kTimeseriesGetRangePath, params, file_path);
-  return DbnFileStore{log_receiver_, file_path, VersionUpgradePolicy::Upgrade};
+  return DbnFileStore{log_receiver_, file_path,
+                      VersionUpgradePolicy::UpgradeToV2};
 }
 
 using databento::HistoricalBuilder;
diff --git a/src/compat.cpp b/src/v1.cpp
similarity index 88%
rename from src/compat.cpp
rename to src/v1.cpp
index 398a5c5..19728cd 100644
--- a/src/compat.cpp
+++ b/src/v1.cpp
@@ -1,4 +1,4 @@
-#include "databento/compat.hpp"
+#include "databento/v1.hpp"
 
 #include <algorithm>  // copy
 #include <cstdint>
@@ -8,11 +8,12 @@
 #include "stream_op_helper.hpp"       // MakeString, StreamOpBuilder
 
 namespace databento {
-InstrumentDefMsgV2 InstrumentDefMsgV1::ToV2() const {
-  InstrumentDefMsgV2 ret{
-      RecordHeader{sizeof(InstrumentDefMsgV2) / RecordHeader::kLengthMultiplier,
-                   RType::InstrumentDef, hd.publisher_id, hd.instrument_id,
-                   hd.ts_event},
+namespace v1 {
+v2::InstrumentDefMsg InstrumentDefMsg::ToV2() const {
+  v2::InstrumentDefMsg ret{
+      RecordHeader{
+          sizeof(v2::InstrumentDefMsg) / RecordHeader::kLengthMultiplier,
+          RType::InstrumentDef, hd.publisher_id, hd.instrument_id, hd.ts_event},
       ts_recv,
       min_price_increment,
       display_factor,
@@ -93,9 +94,9 @@ InstrumentDefMsgV2 InstrumentDefMsgV1::ToV2() const {
   return ret;
 }
 
-ErrorMsgV2 ErrorMsgV1::ToV2() const {
-  ErrorMsgV2 ret{
-      RecordHeader{sizeof(ErrorMsgV2) / RecordHeader::kLengthMultiplier,
+v2::ErrorMsg ErrorMsg::ToV2() const {
+  v2::ErrorMsg ret{
+      RecordHeader{sizeof(v2::ErrorMsg) / RecordHeader::kLengthMultiplier,
                    RType::Error, hd.publisher_id, hd.instrument_id,
                    hd.ts_event},
       {},
@@ -105,11 +106,11 @@ ErrorMsgV2 ErrorMsgV1::ToV2() const {
   return ret;
 }
 
-SymbolMappingMsgV2 SymbolMappingMsgV1::ToV2() const {
-  SymbolMappingMsgV2 ret{
-      RecordHeader{sizeof(SymbolMappingMsgV2) / RecordHeader::kLengthMultiplier,
-                   RType::SymbolMapping, hd.publisher_id, hd.instrument_id,
-                   hd.ts_event},
+v2::SymbolMappingMsg SymbolMappingMsg::ToV2() const {
+  v2::SymbolMappingMsg ret{
+      RecordHeader{
+          sizeof(v2::SymbolMappingMsg) / RecordHeader::kLengthMultiplier,
+          RType::SymbolMapping, hd.publisher_id, hd.instrument_id, hd.ts_event},
       // Intentionally invalid
       // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
       static_cast<SType>(std::numeric_limits<std::uint8_t>::max()),
@@ -127,9 +128,9 @@ SymbolMappingMsgV2 SymbolMappingMsgV1::ToV2() const {
   return ret;
 }
 
-SystemMsgV2 SystemMsgV1::ToV2() const {
-  SystemMsgV2 ret{
-      RecordHeader{sizeof(SystemMsgV2) / RecordHeader::kLengthMultiplier,
+v2::SystemMsg SystemMsg::ToV2() const {
+  v2::SystemMsg ret{
+      RecordHeader{sizeof(v2::SystemMsg) / RecordHeader::kLengthMultiplier,
                    RType::System, hd.publisher_id, hd.instrument_id,
                    hd.ts_event},
       {},
@@ -138,7 +139,7 @@ SystemMsgV2 SystemMsgV1::ToV2() const {
   return ret;
 }
 
-bool operator==(const InstrumentDefMsgV1& lhs, const InstrumentDefMsgV1& rhs) {
+bool operator==(const InstrumentDefMsg& lhs, const InstrumentDefMsg& rhs) {
   return lhs.hd == rhs.hd && lhs.ts_recv == rhs.ts_recv &&
          lhs.min_price_increment == rhs.min_price_increment &&
          lhs.display_factor == rhs.display_factor &&
@@ -195,14 +196,14 @@ bool operator==(const InstrumentDefMsgV1& lhs, const InstrumentDefMsgV1& rhs) {
          lhs.tick_rule == rhs.tick_rule;
 }
 
-std::string ToString(const InstrumentDefMsgV1& instr_def_msg) {
+std::string ToString(const InstrumentDefMsg& instr_def_msg) {
   return MakeString(instr_def_msg);
 }
 std::ostream& operator<<(std::ostream& stream,
-                         const InstrumentDefMsgV1& instr_def_msg) {
+                         const InstrumentDefMsg& instr_def_msg) {
   return StreamOpBuilder{stream}
       .SetSpacer("\n    ")
-      .SetTypeName("InstrumentDefMsg")
+      .SetTypeName("v1::InstrumentDefMsg")
       .Build()
       .AddField("hd", instr_def_msg.hd)
       .AddField("ts_recv", instr_def_msg.ts_recv)
@@ -272,24 +273,24 @@ std::ostream& operator<<(std::ostream& stream,
       .AddField("tick_rule", instr_def_msg.tick_rule)
       .Finish();
 }
-std::string ToString(const ErrorMsgV1& err_msg) { return MakeString(err_msg); }
-std::ostream& operator<<(std::ostream& stream, const ErrorMsgV1& err_msg) {
+std::string ToString(const ErrorMsg& err_msg) { return MakeString(err_msg); }
+std::ostream& operator<<(std::ostream& stream, const ErrorMsg& err_msg) {
   return StreamOpBuilder{stream}
       .SetSpacer("\n    ")
-      .SetTypeName("ErrorMsgV1")
+      .SetTypeName("v1::ErrorMsg")
       .Build()
       .AddField("hd", err_msg.hd)
       .AddField("err", err_msg.err)
       .Finish();
 }
-std::string ToString(const SymbolMappingMsgV1& symbol_mapping_msg) {
+std::string ToString(const SymbolMappingMsg& symbol_mapping_msg) {
   return MakeString(symbol_mapping_msg);
 }
 std::ostream& operator<<(std::ostream& stream,
-                         const SymbolMappingMsgV1& symbol_mapping_msg) {
+                         const SymbolMappingMsg& symbol_mapping_msg) {
   return StreamOpBuilder{stream}
       .SetSpacer("\n    ")
-      .SetTypeName("SymbolMappingMsgV1")
+      .SetTypeName("v1::SymbolMappingMsg")
       .Build()
       .AddField("hd", symbol_mapping_msg.hd)
       .AddField("stype_in_symbol", symbol_mapping_msg.stype_in_symbol)
@@ -298,16 +299,17 @@ std::ostream& operator<<(std::ostream& stream,
       .AddField("end_ts", symbol_mapping_msg.end_ts)
       .Finish();
 }
-std::string ToString(const SystemMsgV1& system_msg) {
+std::string ToString(const SystemMsg& system_msg) {
   return MakeString(system_msg);
 }
-std::ostream& operator<<(std::ostream& stream, const SystemMsgV1& system_msg) {
+std::ostream& operator<<(std::ostream& stream, const SystemMsg& system_msg) {
   return StreamOpBuilder{stream}
       .SetSpacer("\n    ")
-      .SetTypeName("SystemMsgV1")
+      .SetTypeName("v1::SystemMsg")
       .Build()
       .AddField("hd", system_msg.hd)
       .AddField("msg", system_msg.msg)
       .Finish();
 }
+}  // namespace v1
 }  // namespace databento
diff --git a/tests/src/dbn_decoder_tests.cpp b/tests/src/dbn_decoder_tests.cpp
index 460ebcf..3c0000e 100644
--- a/tests/src/dbn_decoder_tests.cpp
+++ b/tests/src/dbn_decoder_tests.cpp
@@ -114,7 +114,7 @@ TEST_F(DbnDecoderTests, TestDecodeDbz) {
 }
 
 TEST_F(DbnDecoderTests, TestDecodeDefinitionUpgrade) {
-  ReadFromFile("definition", ".dbn", 1, VersionUpgradePolicy::Upgrade);
+  ReadFromFile("definition", ".dbn", 1, VersionUpgradePolicy::UpgradeToV2);
 
   const Metadata ch_metadata = channel_target_->DecodeMetadata();
   const Metadata f_metadata = file_target_->DecodeMetadata();
@@ -165,7 +165,7 @@ TEST_F(DbnDecoderTests, TestUpgradeSymbolMappingWithTsOut) {
       sym_map, UnixNanos{std::chrono::system_clock::now()}};
   std::array<std::uint8_t, kMaxRecordLen> compat_buffer{};
   const auto res =
-      DbnDecoder::DecodeRecordCompat(1, VersionUpgradePolicy::Upgrade, true,
+      DbnDecoder::DecodeRecordCompat(1, VersionUpgradePolicy::UpgradeToV2, true,
                                      &compat_buffer, Record{&orig.rec.hd});
   const auto& upgraded = res.Get<WithTsOut<SymbolMappingMsgV2>>();
   EXPECT_EQ(orig.rec.hd.rtype, upgraded.rec.hd.rtype);
@@ -206,7 +206,7 @@ TEST_F(DbnDecoderTests, TestUpgradeMbp1WithTsOut) {
       {std::chrono::system_clock::now()}};
   std::array<std::uint8_t, kMaxRecordLen> compat_buffer{};
   const auto res =
-      DbnDecoder::DecodeRecordCompat(1, VersionUpgradePolicy::Upgrade, true,
+      DbnDecoder::DecodeRecordCompat(1, VersionUpgradePolicy::UpgradeToV2, true,
                                      &compat_buffer, Record{&orig.rec.hd});
   const auto& upgraded = res.Get<WithTsOut<Mbp1Msg>>();
   // compat buffer unused and pointer unchanged
diff --git a/tests/src/live_blocking_tests.cpp b/tests/src/live_blocking_tests.cpp
index f672edf..6bcb0b7 100644
--- a/tests/src/live_blocking_tests.cpp
+++ b/tests/src/live_blocking_tests.cpp
@@ -60,7 +60,7 @@ TEST_F(LiveBlockingTests, TestStartAndUpgrade) {
   constexpr auto kTsOut = true;
   for (const auto policy_and_version :
        {std::make_pair(VersionUpgradePolicy::AsIs, 1),
-        std::make_pair(VersionUpgradePolicy::Upgrade, 2)}) {
+        std::make_pair(VersionUpgradePolicy::UpgradeToV2, 2)}) {
     const mock::MockLsgServer mock_server{dataset::kGlbxMdp3, kTsOut,
                                           [](mock::MockLsgServer& self) {
                                             self.Accept();