diff --git a/api/icsneolegacy/icsneolegacy.cpp b/api/icsneolegacy/icsneolegacy.cpp
index db58439..7fea86a 100644
--- a/api/icsneolegacy/icsneolegacy.cpp
+++ b/api/icsneolegacy/icsneolegacy.cpp
@@ -83,21 +83,21 @@ static bool NeoMessageToSpyMessage(const neodevice_t* device, const neomessage_t
 
 	switch (Network::Type(frame.type))
 	{
-	case Network::Type::CAN:
-	case Network::Type::SWCAN:
-	case Network::Type::LSFTCAN:
+	case icsneo_msg_bus_type_can:
+	case icsneo_msg_bus_type_swcan:
+	case icsneo_msg_bus_type_lsftcan:
 		oldmsg.Protocol = frame.status.canfdFDF ? SPY_PROTOCOL_CANFD : SPY_PROTOCOL_CAN;
 		oldmsg.NumberBytesData = static_cast<uint8_t>(std::min(frame.length, (size_t)255));
 		oldmsg.NumberBytesHeader = 4;
 		copyFrameData();
 		break;
-	case Network::Type::Ethernet:
+	case icsneo_msg_bus_type_ethernet:
 		oldmsg.Protocol = SPY_PROTOCOL_ETHERNET;
 		oldmsg.NumberBytesData = static_cast<uint8_t>(frame.length & 0xFF);
 		oldmsg.NumberBytesHeader = static_cast<uint8_t>(frame.length >> 8);
 		copyFrameData();
 		break;
-	case Network::Type::LIN:
+	case icsneo_msg_bus_type_lin:
 	{
 		const neomessage_lin_t& linFrame = *reinterpret_cast<const neomessage_lin_t*>(&frame);
 		icsSpyMessageJ1850& linSpyMsg = *reinterpret_cast<icsSpyMessageJ1850*>(&oldmsg);
diff --git a/communication/decoder.cpp b/communication/decoder.cpp
index d20c276..eac0cc5 100644
--- a/communication/decoder.cpp
+++ b/communication/decoder.cpp
@@ -54,7 +54,7 @@ uint64_t Decoder::GetUInt64FromLEBytes(const uint8_t* bytes) {
 
 bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Packet>& packet) {
 	switch(packet->network.getType()) {
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: {
+		case icsneo_msg_bus_type_ethernet: {
 			result = HardwareEthernetPacket::DecodeToMessage(packet->data, report);
 			if(!result) {
 				report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
@@ -68,9 +68,9 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 			eth.network = packet->network;
 			return true;
 		}
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: {
+		case icsneo_msg_bus_type_can:
+		case icsneo_msg_bus_type_swcan:
+		case icsneo_msg_bus_type_lsftcan: {
 			if(packet->data.size() < 24) {
 				report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
 				return false;
@@ -105,7 +105,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 
 			return true;
 		}
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_flexray: {
+		case icsneo_msg_bus_type_flexray: {
 			if(packet->data.size() < 24) {
 				report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
 				return false;
@@ -124,7 +124,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 			fr.network = packet->network;
 			return true;
 		}
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141: {
+		case icsneo_msg_bus_type_iso9141: {
 			if(packet->data.size() < sizeof(HardwareISO9141Packet)) {
 				report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
 				return false;
@@ -141,7 +141,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 			iso.network = packet->network;
 			return true;
 		}
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c: {
+		case icsneo_msg_bus_type_i2c: {
 			if(packet->data.size() < sizeof(HardwareI2CPacket)) {
 				report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
 				return false;
@@ -155,7 +155,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 
 			return true;
 		}
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b: {
+		case icsneo_msg_bus_type_a2b: {
 			result = HardwareA2BPacket::DecodeToMessage(packet->data);
 
 			if(!result) {
@@ -168,7 +168,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 			msg.timestamp *= timestampResolution;
 			return true;
 		}
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
+		case icsneo_msg_bus_type_lin: {
 			result = HardwareLINPacket::DecodeToMessage(packet->data);
 
 			if(!result) {
@@ -180,7 +180,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 			msg.network = packet->network;
 			return true;
 		}
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio: {
+		case icsneo_msg_bus_type_mdio: {
 			result = HardwareMDIOPacket::DecodeToMessage(packet->data);
 
 			if(!result) {
@@ -192,7 +192,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 			msg.network = packet->network;
 			return true;
 		}
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal: {
+		case icsneo_msg_bus_type_internal: {
 			switch(packet->network.getNetID()) {
 				case Network::NetID::Reset_Status: {
 					// We can deal with not having the last two fields (voltage and temperature)
diff --git a/communication/encoder.cpp b/communication/encoder.cpp
index fe6258c..8918bb1 100644
--- a/communication/encoder.cpp
+++ b/communication/encoder.cpp
@@ -31,7 +31,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 			netid = uint16_t(frame->network.getNetID());
 
 			switch(frame->network.getType()) {
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: {
+				case icsneo_msg_bus_type_ethernet: {
 					auto ethmsg = std::dynamic_pointer_cast<EthernetMessage>(message);
 					if(!ethmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -43,10 +43,10 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 						return false;
 
 					break;
-				} // End of Network::Type::Ethernet
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: {
+				} // End of icsneo_msg_bus_type_ethernet
+				case icsneo_msg_bus_type_can:
+				case icsneo_msg_bus_type_swcan:
+				case icsneo_msg_bus_type_lsftcan: {
 					auto canmsg = std::dynamic_pointer_cast<CANMessage>(message);
 					if(!canmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -63,8 +63,8 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 						return false; // The CANMessage was malformed
 
 					break;
-				} // End of Network::Type::CAN
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141: {
+				} // End of icsneo_msg_bus_type_can
+				case icsneo_msg_bus_type_iso9141: {
 					auto isomsg = std::dynamic_pointer_cast<ISO9141Message>(message);
 					if(!isomsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -74,8 +74,8 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 					// Skip the normal message wrapping at the bottom since we need to send multiple
 					// packets to the device. This function just encodes them back to back into `result`
 					return HardwareISO9141Packet::EncodeFromMessage(*isomsg, result, report, packetizer);
-				} // End of Network::Type::ISO9141
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b: {
+				} // End of icsneo_msg_bus_type_iso9141
+				case icsneo_msg_bus_type_a2b: {
 					auto a2bmsg = std::dynamic_pointer_cast<A2BMessage>(message);
 					if(!a2bmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -86,8 +86,8 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 						return false;
 					}
 					break;
-				} // End of Network::Type::A2B
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c: {
+				} // End of icsneo_msg_bus_type_a2b
+				case icsneo_msg_bus_type_i2c: {
 					auto i2cmsg = std::dynamic_pointer_cast<I2CMessage>(message);
 					if(!i2cmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -98,8 +98,8 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 						return false;
 					}
 					break;
-				} // End of Network::Type::I2C
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
+				} // End of icsneo_msg_bus_type_i2c
+				case icsneo_msg_bus_type_lin: {
 					auto linmsg = std::dynamic_pointer_cast<LINMessage>(message);
 					if(!linmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -110,8 +110,8 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 						return false;
 					}
 					break;
-				} // End of Network::Type::LIN
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio: {
+				} // End of icsneo_msg_bus_type_lin
+				case icsneo_msg_bus_type_mdio: {
 					auto mdiomsg = std::dynamic_pointer_cast<MDIOMessage>(message);
 					if(!mdiomsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -122,7 +122,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 						return false;
 					}
 					break;
-				} // End of Network::Type::MDIO
+				} // End of icsneo_msg_bus_type_mdio
 				default:
 					report(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::Error);
 					return false;
diff --git a/communication/message/callback/streamoutput/a2bwavoutput.cpp b/communication/message/callback/streamoutput/a2bwavoutput.cpp
index 23662b6..cc325d6 100644
--- a/communication/message/callback/streamoutput/a2bwavoutput.cpp
+++ b/communication/message/callback/streamoutput/a2bwavoutput.cpp
@@ -112,7 +112,7 @@ bool A2BWAVOutput::callIfMatch(const std::shared_ptr<Message>& message) const {
 		return false;
 	}
 
-	if(frameMsg->network.getType() != _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b)
+	if(frameMsg->network.getType() != icsneo_msg_bus_type_a2b)
 		return false;
 
 	const auto& a2bMsg = std::dynamic_pointer_cast<A2BMessage>(frameMsg);
diff --git a/communication/message/neomessage.cpp b/communication/message/neomessage.cpp
index 5027d1b..7818ea1 100644
--- a/communication/message/neomessage.cpp
+++ b/communication/message/neomessage.cpp
@@ -29,9 +29,9 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 		frame.status.transmitMessage = framemsg->transmitted;
 
 		switch(netType) {
-			case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
-			case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
-			case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: {
+			case icsneo_msg_bus_type_can:
+			case icsneo_msg_bus_type_swcan:
+			case icsneo_msg_bus_type_lsftcan: {
 				neomessage_can_t& can = *(neomessage_can_t*)&neomsg;
 				auto canmsg = std::static_pointer_cast<CANMessage>(message);
 				can.arbid = canmsg->arbid;
@@ -44,7 +44,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 				can.status.canfdESI = canmsg->errorStateIndicator;
 				break;
 			}
-			case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: {
+			case icsneo_msg_bus_type_ethernet: {
 				neomessage_eth_t& eth = *(neomessage_eth_t*)&neomsg;
 				auto ethmsg = std::static_pointer_cast<EthernetMessage>(message);
 				eth.preemptionFlags = ethmsg->preemptionFlags;
@@ -55,7 +55,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 				//eth.status.xyz = ethmsg->noPadding;
 				break;
 			}
-			case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
+			case icsneo_msg_bus_type_lin: {
 				neomessage_lin_t& lin = *(neomessage_lin_t*)&neomsg;
 				auto linmsg = std::static_pointer_cast<LINMessage>(message);
 				if(!linmsg) { break; }
@@ -123,9 +123,9 @@ std::shared_ptr<Message> icsneo::CreateMessageFromNeoMessage(const neomessage_t*
 		case Message::Type::Frame: {
 			const Network network = ((neomessage_frame_t*)neomessage)->netid;
 			switch(network.getType()) {
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: {
+				case icsneo_msg_bus_type_can:
+				case icsneo_msg_bus_type_swcan:
+				case icsneo_msg_bus_type_lsftcan: {
 					neomessage_can_t& can = *(neomessage_can_t*)neomessage;
 					auto canmsg = std::make_shared<CANMessage>();
 					canmsg->network = network;
@@ -140,7 +140,7 @@ std::shared_ptr<Message> icsneo::CreateMessageFromNeoMessage(const neomessage_t*
 					canmsg->errorStateIndicator = can.status.canfdESI;
 					return canmsg;
 				}
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: {
+				case icsneo_msg_bus_type_ethernet: {
 					neomessage_eth_t& eth = *(neomessage_eth_t*)neomessage;
 					auto ethmsg = std::make_shared<EthernetMessage>();
 					ethmsg->network = network;
@@ -148,7 +148,7 @@ std::shared_ptr<Message> icsneo::CreateMessageFromNeoMessage(const neomessage_t*
 					ethmsg->data.insert(ethmsg->data.end(), eth.data, eth.data + eth.length);
 					return ethmsg;
 				}
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
+				case icsneo_msg_bus_type_lin: {
 					neomessage_lin_t& lin = *(neomessage_lin_t*)neomessage;
 					auto linmsg = std::make_shared<LINMessage>();
 					linmsg->network = network;
diff --git a/device/extensions/flexray/extension.cpp b/device/extensions/flexray/extension.cpp
index 05f938a..cf3aa93 100644
--- a/device/extensions/flexray/extension.cpp
+++ b/device/extensions/flexray/extension.cpp
@@ -49,7 +49,7 @@ void FlexRay::Extension::handleMessage(const std::shared_ptr<Message>& message)
 }
 
 bool FlexRay::Extension::transmitHook(const std::shared_ptr<BusMessage>& frame, bool& success) {
-	if(!frame || frame->network.getType() != _icsneo_msg_bus_type_t::icsneo_msg_bus_type_flexray)
+	if(!frame || frame->network.getType() != icsneo_msg_bus_type_flexray)
 		return true; // Don't hook non-FlexRay messages
 
 	success = false;
diff --git a/device/idevicesettings.cpp b/device/idevicesettings.cpp
index e0ee662..bbad433 100644
--- a/device/idevicesettings.cpp
+++ b/device/idevicesettings.cpp
@@ -403,7 +403,7 @@ int64_t IDeviceSettings::getBaudrateFor(Network net) const {
 	}
 
 	switch(net.getType()) {
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: {
+		case icsneo_msg_bus_type_can: {
 			const CAN_SETTINGS* cfg = getCANSettingsFor(net);
 			if(cfg == nullptr) {
 				report(APIEvent::Type::CANSettingsNotAvailable, APIEvent::Severity::Error);
@@ -417,7 +417,7 @@ int64_t IDeviceSettings::getBaudrateFor(Network net) const {
 			}
 			return baudrate;
 		}
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan: {
+		case icsneo_msg_bus_type_swcan: {
 			const SWCAN_SETTINGS* cfg = getSWCANSettingsFor(net);
 			if(cfg == nullptr) {
 				report(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::Error);
@@ -431,7 +431,7 @@ int64_t IDeviceSettings::getBaudrateFor(Network net) const {
 			}
 			return baudrate;
 		}
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: {
+		case icsneo_msg_bus_type_lsftcan: {
 			const CAN_SETTINGS* cfg = getLSFTCANSettingsFor(net);
 			if(cfg == nullptr) {
 				report(APIEvent::Type::LSFTCANSettingsNotAvailable, APIEvent::Severity::Error);
@@ -445,7 +445,7 @@ int64_t IDeviceSettings::getBaudrateFor(Network net) const {
 			}
 			return baudrate;
 		}
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
+		case icsneo_msg_bus_type_lin: {
 			const LIN_SETTINGS* cfg = getLINSettingsFor(net);
 			if(cfg == nullptr) {
 				report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@@ -477,7 +477,7 @@ bool IDeviceSettings::setBaudrateFor(Network net, int64_t baudrate) {
 	}
 
 	switch(net.getType()) {
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: {
+		case icsneo_msg_bus_type_can: {
 			if(baudrate > 1000000) { // This is an FD baudrate. Use setFDBaudrateFor instead.
 				report(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::Error);
 				return false;
@@ -499,7 +499,7 @@ bool IDeviceSettings::setBaudrateFor(Network net, int64_t baudrate) {
 			cfg->SetBaudrate = AUTO; // Device will use the baudrate value to set the TQ values
 			return true;
 		}
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: {
+		case icsneo_msg_bus_type_lsftcan: {
 			CAN_SETTINGS* cfg = getMutableLSFTCANSettingsFor(net);
 			if(cfg == nullptr) {
 				report(APIEvent::Type::LSFTCANSettingsNotAvailable, APIEvent::Severity::Error);
@@ -516,7 +516,7 @@ bool IDeviceSettings::setBaudrateFor(Network net, int64_t baudrate) {
 			cfg->SetBaudrate = AUTO; // Device will use the baudrate value to set the TQ values
 			return true;
 		}
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan: {
+		case icsneo_msg_bus_type_swcan: {
 			SWCAN_SETTINGS* cfg = getMutableSWCANSettingsFor(net);
 			if(cfg == nullptr) {
 				report(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::Error);
@@ -533,7 +533,7 @@ bool IDeviceSettings::setBaudrateFor(Network net, int64_t baudrate) {
 			cfg->SetBaudrate = AUTO; // Device will use the baudrate value to set the TQ values
 			return true;
 		}
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
+		case icsneo_msg_bus_type_lin: {
 			LIN_SETTINGS* cfg = getMutableLINSettingsFor(net);
 			if(cfg == nullptr) {
 				report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@@ -566,7 +566,7 @@ int64_t IDeviceSettings::getFDBaudrateFor(Network net) const {
 	}
 
 	switch(net.getType()) {
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: {
+		case icsneo_msg_bus_type_can: {
 			const CANFD_SETTINGS* cfg = getCANFDSettingsFor(net);
 			if(cfg == nullptr) {
 				report(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::Error);
@@ -604,7 +604,7 @@ bool IDeviceSettings::setFDBaudrateFor(Network net, int64_t baudrate) {
 	}
 
 	switch(net.getType()) {
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: {
+		case icsneo_msg_bus_type_can: {
 			CANFD_SETTINGS* cfg = getMutableCANFDSettingsFor(net);
 			if(cfg == nullptr) {
 				report(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::Error);
@@ -771,7 +771,7 @@ std::optional<bool> IDeviceSettings::isCommanderResistorEnabledFor(Network net)
 	}
 
 	switch(net.getType()) {
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
+		case icsneo_msg_bus_type_lin: {
 			const LIN_SETTINGS* cfg = getLINSettingsFor(net);
 			if(cfg == nullptr) {
 				report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@@ -803,7 +803,7 @@ bool IDeviceSettings::setCommanderResistorFor(Network net, bool resistor_on) {
 	}
 
 	switch(net.getType()) {
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
+		case icsneo_msg_bus_type_lin: {
 			LIN_SETTINGS* cfg = getMutableLINSettingsFor(net);
 			if(cfg == nullptr) {
 				report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@@ -831,7 +831,7 @@ std::optional<LINMode> IDeviceSettings::getLINModeFor(Network net) const {
 	}
 
 	switch(net.getType()) {
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
+		case icsneo_msg_bus_type_lin: {
 			const LIN_SETTINGS* cfg = getLINSettingsFor(net);
 			if(cfg == nullptr) {
 				report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@@ -863,7 +863,7 @@ bool IDeviceSettings::setLINModeFor(Network net, LINMode mode) {
 	}
 
 	switch(net.getType()) {
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
+		case icsneo_msg_bus_type_lin: {
 			LIN_SETTINGS* cfg = getMutableLINSettingsFor(net);
 			if(cfg == nullptr) {
 				report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@@ -891,7 +891,7 @@ std::optional<uint8_t> IDeviceSettings::getLINCommanderResponseTimeFor(Network n
 	}
 
 	switch(net.getType()) {
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
+		case icsneo_msg_bus_type_lin: {
 			const LIN_SETTINGS* cfg = getLINSettingsFor(net);
 			if(cfg == nullptr) {
 				report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@@ -923,7 +923,7 @@ bool IDeviceSettings::setLINCommanderResponseTimeFor(Network net, uint8_t bits)
 	}
 
 	switch(net.getType()) {
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
+		case icsneo_msg_bus_type_lin: {
 			LIN_SETTINGS* cfg = getMutableLINSettingsFor(net);
 			if(cfg == nullptr) {
 				report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
diff --git a/disk/vsa/vsa.cpp b/disk/vsa/vsa.cpp
index f7e74d1..761b220 100644
--- a/disk/vsa/vsa.cpp
+++ b/disk/vsa/vsa.cpp
@@ -31,7 +31,7 @@ void VSAExtendedMessage::truncatePacket(std::shared_ptr<Packet> packet)
 {
 	static constexpr auto EthernetLengthOffset = 26u;
 	switch(packet->network.getType()) {
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet:
+		case icsneo_msg_bus_type_ethernet:
 			{
 				const auto& packetLength = *reinterpret_cast<uint16_t*>(packet->data.data() + EthernetLengthOffset);
 				const size_t ethernetFrameSize = packetLength - (sizeof(uint16_t) * 2);
diff --git a/docs/icsneocpp/examples.rst b/docs/icsneocpp/examples.rst
index 87f3460..a4d3df4 100644
--- a/docs/icsneocpp/examples.rst
+++ b/docs/icsneocpp/examples.rst
@@ -36,9 +36,9 @@ the arbitration ID.
    std::cout << "We got " << messages.size() << " messages!" << std::endl;
    for(auto& msg : messages) {
        switch(msg->network.getType()) {
-           case icsneo::Network::Type::CAN:
-           case icsneo::Network::Type::SWCAN:
-           case icsneo::Network::Type::LSFTCAN: {
+           case icsneo::icsneo_msg_bus_type_can:
+           case icsneo::icsneo_msg_bus_type_swcan:
+           case icsneo::icsneo_msg_bus_type_lsftcan: {
                // A message of type CAN is guaranteed to be a CANMessage, so we can static cast safely
                auto canmsg = std::static_pointer_cast<icsneo::CANMessage>(msg);
                // canmsg->arbid is valid here
diff --git a/examples/cpp/a2b/src/a2b.cpp b/examples/cpp/a2b/src/a2b.cpp
index 2d8cc29..2273b72 100644
--- a/examples/cpp/a2b/src/a2b.cpp
+++ b/examples/cpp/a2b/src/a2b.cpp
@@ -392,11 +392,11 @@ int main(int argc, char** argv) {
 			const auto& txNetworks = dev->getSupportedTXNetworks();
 			const auto& rxNetworks = dev->getSupportedRXNetworks();
 
-			if(std::none_of(txNetworks.begin(), txNetworks.end(), [](const icsneo::Network& net) { return net.getType() == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b; })) {
+			if(std::none_of(txNetworks.begin(), txNetworks.end(), [](const icsneo::Network& net) { return net.getType() == icsneo_msg_bus_type_a2b; })) {
 				return false;
 			}
 
-			if(std::none_of(rxNetworks.begin(), rxNetworks.end(), [](const icsneo::Network& net) { return net.getType() == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b; })) {
+			if(std::none_of(rxNetworks.begin(), rxNetworks.end(), [](const icsneo::Network& net) { return net.getType() == icsneo_msg_bus_type_a2b; })) {
 				return false;
 			}
 
diff --git a/examples/cpp/interactive/src/InteractiveExample.cpp b/examples/cpp/interactive/src/InteractiveExample.cpp
index 9b0e491..f8d13e8 100644
--- a/examples/cpp/interactive/src/InteractiveExample.cpp
+++ b/examples/cpp/interactive/src/InteractiveExample.cpp
@@ -188,7 +188,7 @@ void printMessage(const std::shared_ptr<icsneo::Message>& message) {
 			// A message of type Frame is guaranteed to be a Frame, so we can static cast safely
 			auto frame = std::static_pointer_cast<icsneo::BusMessage>(message);
 			switch(frame->network.getType()) {
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: {
+				case icsneo_msg_bus_type_can: {
 					// A message of type CAN is guaranteed to be a CANMessage, so we can static cast safely
 					auto canMessage = std::static_pointer_cast<icsneo::CANMessage>(message);
 
@@ -214,7 +214,7 @@ void printMessage(const std::shared_ptr<icsneo::Message>& message) {
 					std::cout << std::dec << '(' << canMessage->timestamp << " ns since 1/1/2007)\n";
 					break;
 				}
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: {
+				case icsneo_msg_bus_type_ethernet: {
 					auto ethMessage = std::static_pointer_cast<icsneo::EthernetMessage>(message);
 
 					std::cout << "\t\t" << ethMessage->network << " Frame - " << std::dec
@@ -235,7 +235,7 @@ void printMessage(const std::shared_ptr<icsneo::Message>& message) {
 					std::cout << std::dec << std::endl;
 					break;
 				}
-				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141: {
+				case icsneo_msg_bus_type_iso9141: {
 					// Note that the default settings on some devices have ISO9141 disabled by default in favor of LIN
 					// and that this example loads the device defaults at the very end.
 					// A message of type ISO9414 is guaranteed to be an ISO9141Message, so we can static cast safely
diff --git a/examples/cpp/lin/src/LINExample.cpp b/examples/cpp/lin/src/LINExample.cpp
index 52e552c..f8f3a6f 100644
--- a/examples/cpp/lin/src/LINExample.cpp
+++ b/examples/cpp/lin/src/LINExample.cpp
@@ -98,7 +98,7 @@ int main() {
 		auto handler = device->addMessageCallback(std::make_shared<icsneo::MessageCallback>([&](std::shared_ptr<icsneo::Message> message) {
 			if(icsneo::Message::Type::Frame == message->type) {
 				auto frame = std::static_pointer_cast<icsneo::BusMessage>(message);
-				if(_icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin == frame->network.getType()) {
+				if(icsneo_msg_bus_type_lin == frame->network.getType()) {
 					auto msg = std::static_pointer_cast<icsneo::LINMessage>(message);
 					std::cout << msg->network << " RX frame | ID: 0x" << std::hex << static_cast<int>(msg->ID) << " | ";
 					std::cout << "Protected ID: 0x" << static_cast<int>(msg->protectedID) << "\n" << "Data: ";
diff --git a/examples/cpp/mdio/src/MDIOExample.cpp b/examples/cpp/mdio/src/MDIOExample.cpp
index 79aed24..97ba03d 100644
--- a/examples/cpp/mdio/src/MDIOExample.cpp
+++ b/examples/cpp/mdio/src/MDIOExample.cpp
@@ -94,7 +94,7 @@ int main()
 																							{
 			if(icsneo::Message::Type::Frame == message->type) {
 				auto frame = std::static_pointer_cast<icsneo::BusMessage>(message);
-				if(_icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio == frame->network.getType()) {
+				if(icsneo_msg_bus_type_mdio == frame->network.getType()) {
 					auto msg = std::static_pointer_cast<icsneo::MDIOMessage>(message);
 					std::cout << msg->network << " " << ((msg->isTXMsg)? "TX" : "RX") << " frame\n";
 					std::cout << "Clause: " << ((msg->clause ==  icsneo::MDIOMessage::Clause::Clause22) ? "22" : "45") << "\n";
diff --git a/examples/cpp/simple/src/SimpleExample.cpp b/examples/cpp/simple/src/SimpleExample.cpp
index e9d2053..c8d6086 100644
--- a/examples/cpp/simple/src/SimpleExample.cpp
+++ b/examples/cpp/simple/src/SimpleExample.cpp
@@ -173,7 +173,7 @@ int main() {
 					// A message of type Frame is guaranteed to be a Frame, so we can static cast safely
 					auto frame = std::static_pointer_cast<icsneo::BusMessage>(message);
 					switch(frame->network.getType()) {
-						case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: {
+						case icsneo_msg_bus_type_can: {
 							// A message of type CAN is guaranteed to be a CANMessage, so we can static cast safely
 							auto canMessage = std::static_pointer_cast<icsneo::CANMessage>(message);
 
@@ -199,7 +199,7 @@ int main() {
 							std::cout << std::dec << '(' << canMessage->timestamp << " ns since 1/1/2007)\n";
 							break;
 						}
-						case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: {
+						case icsneo_msg_bus_type_ethernet: {
 							auto ethMessage = std::static_pointer_cast<icsneo::EthernetMessage>(message);
 
 							std::cout << "\t\t" << ethMessage->network << " Frame - " << std::dec
@@ -220,7 +220,7 @@ int main() {
 							std::cout << std::dec << std::endl;
 							break;
 						}
-						case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141: {
+						case icsneo_msg_bus_type_iso9141: {
 							// Note that the default settings on some devices have ISO9141 disabled by default in favor of LIN
 							// and that this example loads the device defaults at the very end.
 							// A message of type ISO9414 is guaranteed to be an ISO9141Message, so we can static cast safely
diff --git a/examples/cpp/vsa/src/VSAExample.cpp b/examples/cpp/vsa/src/VSAExample.cpp
index 235a235..8e18e37 100644
--- a/examples/cpp/vsa/src/VSAExample.cpp
+++ b/examples/cpp/vsa/src/VSAExample.cpp
@@ -170,9 +170,9 @@ int main(int argc, char* argv[]) {
 			return;
 		}
 		const auto frame = std::static_pointer_cast<icsneo::BusMessage>(msg);
-		if(frame->network.getType() == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can) {
+		if(frame->network.getType() == icsneo_msg_bus_type_can) {
 			++canFrameCount;
-		} else if(frame->network.getType() == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet) {
+		} else if(frame->network.getType() == icsneo_msg_bus_type_ethernet) {
 			++ethFrameCount;
 		}
 	}));
diff --git a/include/icsneo/communication/message/filter/canmessagefilter.h b/include/icsneo/communication/message/filter/canmessagefilter.h
index 0c86e7f..edbb89e 100644
--- a/include/icsneo/communication/message/filter/canmessagefilter.h
+++ b/include/icsneo/communication/message/filter/canmessagefilter.h
@@ -13,8 +13,8 @@ namespace icsneo {
 
 class CANMessageFilter : public MessageFilter {
 public:
-	CANMessageFilter() : MessageFilter(_icsneo_msg_bus_type_t::icsneo_msg_bus_type_can), arbid(INVALID_ARBID) { messageType = Message::Type::Frame; }
-	CANMessageFilter(uint32_t arbid) : MessageFilter(_icsneo_msg_bus_type_t::icsneo_msg_bus_type_can), arbid(arbid) { messageType = Message::Type::Frame; }
+	CANMessageFilter() : MessageFilter(icsneo_msg_bus_type_can), arbid(INVALID_ARBID) { messageType = Message::Type::Frame; }
+	CANMessageFilter(uint32_t arbid) : MessageFilter(icsneo_msg_bus_type_can), arbid(arbid) { messageType = Message::Type::Frame; }
 
 	bool match(const std::shared_ptr<Message>& message) const {
 		if(!MessageFilter::match(message))
diff --git a/include/icsneo/communication/message/filter/messagefilter.h b/include/icsneo/communication/message/filter/messagefilter.h
index 3ecd4a3..530ca8e 100644
--- a/include/icsneo/communication/message/filter/messagefilter.h
+++ b/include/icsneo/communication/message/filter/messagefilter.h
@@ -15,9 +15,9 @@ public:
 	MessageFilter(Message::Type type) : includeInternalInAny(neomessagetype_t(type) & 0x8000), messageType(type) {}
 	MessageFilter(Network::NetID netid) : MessageFilter(Network::GetTypeOfNetID(netid, false), netid) {} // Messages on the communication layer are never encoded as VNET ID + common ID, so skip the expansion step
 	MessageFilter(icsneo_msg_bus_type_t type, Network::NetID net = Network::NetID::Any) : networkType(type), netid(net) {
-		// If a Network::Type::Internal is used, we want to also get internal Message::Types
+		// If a icsneo_msg_bus_type_internal is used, we want to also get internal Message::Types
 		// The NetID we want may be in there
-		includeInternalInAny = (networkType == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal);
+		includeInternalInAny = (networkType == icsneo_msg_bus_type_internal);
 	}
 	virtual ~MessageFilter() = default;
 	// When getting "all" types of messages, include the ones marked as "internal only"
@@ -34,7 +34,7 @@ public:
 				return false;
 			if(!matchNetID(frame->network.getNetID()))
 				return false;
-		} else if (netid != Network::NetID::Any || networkType != _icsneo_msg_bus_type_t::icsneo_msg_bus_type_any) {
+		} else if (netid != Network::NetID::Any || networkType != icsneo_msg_bus_type_any) {
 			return false; // Filtering on a NetID or Type, but this message doesn't have one
 		}
 		return true;
@@ -48,9 +48,9 @@ protected:
 		return messageType == mtype;
 	}
 
-	icsneo_msg_bus_type_t networkType = _icsneo_msg_bus_type_t::icsneo_msg_bus_type_any;
+	icsneo_msg_bus_type_t networkType = icsneo_msg_bus_type_any;
 	bool matchNetworkType(icsneo_msg_bus_type_t mtype) const {
-		if(networkType == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_any && (mtype != _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal || includeInternalInAny))
+		if(networkType == icsneo_msg_bus_type_any && (mtype != icsneo_msg_bus_type_internal || includeInternalInAny))
 			return true;
 		return networkType == mtype;
 	}
diff --git a/include/icsneo/communication/network.h b/include/icsneo/communication/network.h
index fce438f..83d014b 100644
--- a/include/icsneo/communication/network.h
+++ b/include/icsneo/communication/network.h
@@ -291,35 +291,35 @@ public:
 	};
 	static const char* GetTypeString(icsneo_msg_bus_type_t type) {
 		switch(type) {
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
+		case icsneo_msg_bus_type_can:
 			return "CAN";
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin:
+		case icsneo_msg_bus_type_lin:
 			return "LIN";
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_flexray:
+		case icsneo_msg_bus_type_flexray:
 			return "FlexRay";
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_most:
+		case icsneo_msg_bus_type_most:
 			return "MOST";
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_other:
+		case icsneo_msg_bus_type_other:
 			return "Other";
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal:
+		case icsneo_msg_bus_type_internal:
 			return "Internal";
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141:
+		case icsneo_msg_bus_type_iso9141:
 			return "ISO 9141-2";
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet:
+		case icsneo_msg_bus_type_ethernet:
 			return "Ethernet";
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan:
+		case icsneo_msg_bus_type_lsftcan:
 			return "Low Speed Fault Tolerant CAN";
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
+		case icsneo_msg_bus_type_swcan:
 			return "Single Wire CAN";
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c:
+		case icsneo_msg_bus_type_i2c:
 			return "I²C";
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b:
+		case icsneo_msg_bus_type_a2b:
 			return "A2B";
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_spi:
+		case icsneo_msg_bus_type_spi:
 			return "SPI";
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio:
+		case icsneo_msg_bus_type_mdio:
 			return "MDIO";
-		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_invalid:
+		case icsneo_msg_bus_type_invalid:
 		default:
 			return "Invalid Type";
 		}
@@ -515,7 +515,7 @@ public:
 		case NetID::DWCAN14:
 		case NetID::DWCAN15:
 		case NetID::DWCAN16:
-			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can;
+			return icsneo_msg_bus_type_can;
 		case NetID::LIN:
 		case NetID::LIN2:
 		case NetID::LIN3:
@@ -532,18 +532,18 @@ public:
 		case NetID::LIN14:
 		case NetID::LIN15:
 		case NetID::LIN16:
-			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin;
+			return icsneo_msg_bus_type_lin;
 		case NetID::FlexRay:
 		case NetID::FlexRay1a:
 		case NetID::FlexRay1b:
 		case NetID::FlexRay2:
 		case NetID::FlexRay2a:
 		case NetID::FlexRay2b:
-			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_flexray;
+			return icsneo_msg_bus_type_flexray;
 		case NetID::MOST25:
 		case NetID::MOST50:
 		case NetID::MOST150:
-			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_most;
+			return icsneo_msg_bus_type_most;
 		case NetID::RED:
 		case NetID::RED_OLDFORMAT:
 		case NetID::Device:
@@ -565,10 +565,10 @@ public:
 		case NetID::RED_GET_RTC:
 		case NetID::DiskData:
 		case NetID::RED_App_Error:
-			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal;
+			return icsneo_msg_bus_type_internal;
 		case NetID::Invalid:
 		case NetID::Any:
-			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_invalid;
+			return icsneo_msg_bus_type_invalid;
 		case NetID::Ethernet:
 		case NetID::Ethernet_DAQ:
 		case NetID::Ethernet2:
@@ -589,26 +589,26 @@ public:
 		case NetID::OP_Ethernet14:
 		case NetID::OP_Ethernet15:
 		case NetID::OP_Ethernet16:
-			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet;
+			return icsneo_msg_bus_type_ethernet;
 		case NetID::LSFTCAN:
 		case NetID::LSFTCAN2:
-			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan;
+			return icsneo_msg_bus_type_lsftcan;
 		case NetID::SWCAN:
 		case NetID::SWCAN2:
-			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan;
+			return icsneo_msg_bus_type_swcan;
 		case NetID::ISO9141:
 		case NetID::ISO9141_2:
 		case NetID::ISO9141_3:
 		case NetID::ISO9141_4:
-			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141;
+			return icsneo_msg_bus_type_iso9141;
 		case NetID::I2C:
 		case NetID::I2C2:
 		case NetID::I2C3:
 		case NetID::I2C4:
-			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c;
+			return icsneo_msg_bus_type_i2c;
 		case NetID::A2B1:
 		case NetID::A2B2:
-			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b;
+			return icsneo_msg_bus_type_a2b;
 		case NetID::SPI1:
 		case NetID::SPI2:
 		case NetID::SPI3:
@@ -617,7 +617,7 @@ public:
 		case NetID::SPI6:
 		case NetID::SPI7:
 		case NetID::SPI8:
-			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_spi;
+			return icsneo_msg_bus_type_spi;
 		case NetID::MDIO1:
 		case NetID::MDIO2:
 		case NetID::MDIO3:
@@ -626,9 +626,9 @@ public:
 		case NetID::MDIO6:
 		case NetID::MDIO7:
 		case NetID::MDIO8:
-			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio;
+			return icsneo_msg_bus_type_mdio;
 		default:
-			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_other;
+			return icsneo_msg_bus_type_other;
 		}
 	}
 	static const char* GetNetIDString(NetID netid, bool expand = true) {