diff --git a/api/icsneoc/icsneoc.cpp b/api/icsneoc/icsneoc.cpp
index 02cbf6f..8b86ba6 100644
--- a/api/icsneoc/icsneoc.cpp
+++ b/api/icsneoc/icsneoc.cpp
@@ -274,10 +274,10 @@ bool icsneo_removeMessageCallback(const neodevice_t* device, int id) {
 	return device->device->removeMessageCallback(id);
 }
 
-neonetid_t icsneo_getNetworkByNumber(const neodevice_t* device, neonettype_t type, unsigned int number) {
+neonetid_t icsneo_getNetworkByNumber(const neodevice_t* device, icsneo_msg_bus_type_t type, unsigned int number) {
 	if(!icsneo_isValidNeoDevice(device))
 		return false;
-	return neonetid_t(device->device->getNetworkByNumber(icsneo::Network::Type(type), size_t(number)).getNetID());
+	return neonetid_t(device->device->getNetworkByNumber(icsneo::icsneo_msg_bus_type_t(type), size_t(number)).getNetID());
 }
 
 bool icsneo_getProductName(const neodevice_t* device, char* str, size_t* maxLength) {
diff --git a/communication/decoder.cpp b/communication/decoder.cpp
index ac00464..0fbe17f 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 Network::Type::Ethernet: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::CAN:
-		case Network::Type::SWCAN:
-		case Network::Type::LSFTCAN: {
+		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: {
 			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 Network::Type::FlexRay: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::ISO9141: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::I2C: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::A2B: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::LIN: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::MDIO: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::Internal: {
+		case _icsneo_msg_bus_type_t::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 25c10dc..4bbd0f5 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 Network::Type::Ethernet: {
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: {
 					auto ethmsg = std::dynamic_pointer_cast<EthernetMessage>(message);
 					if(!ethmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -44,9 +44,9 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 
 					break;
 				} // End of Network::Type::Ethernet
-				case Network::Type::CAN:
-				case Network::Type::SWCAN:
-				case Network::Type::LSFTCAN: {
+				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: {
 					auto canmsg = std::dynamic_pointer_cast<CANMessage>(message);
 					if(!canmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -64,7 +64,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 
 					break;
 				} // End of Network::Type::CAN
-				case Network::Type::ISO9141: {
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141: {
 					auto isomsg = std::dynamic_pointer_cast<ISO9141Message>(message);
 					if(!isomsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -75,7 +75,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 					// 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 Network::Type::A2B: {
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b: {
 					auto a2bmsg = std::dynamic_pointer_cast<A2BMessage>(message);
 					if(!a2bmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -87,7 +87,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 					}
 					break;
 				} // End of Network::Type::A2B
-				case Network::Type::I2C: {
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c: {
 					auto i2cmsg = std::dynamic_pointer_cast<I2CMessage>(message);
 					if(!i2cmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -99,7 +99,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 					}
 					break;
 				} // End of Network::Type::I2C
-				case Network::Type::LIN: {
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
 					auto linmsg = std::dynamic_pointer_cast<LINMessage>(message);
 					if(!linmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -111,7 +111,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 					}
 					break;
 				} // End of Network::Type::LIN
-				case Network::Type::MDIO: {
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio: {
 					auto mdiomsg = std::dynamic_pointer_cast<MDIOMessage>(message);
 					if(!mdiomsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
diff --git a/communication/message/callback/streamoutput/a2bwavoutput.cpp b/communication/message/callback/streamoutput/a2bwavoutput.cpp
index f5830bd..b9cf227 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() != Network::Type::A2B)
+	if(frameMsg->network.getType() != _icsneo_msg_bus_type_t::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 acaab67..da99a45 100644
--- a/communication/message/neomessage.cpp
+++ b/communication/message/neomessage.cpp
@@ -20,7 +20,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 		const auto netType = framemsg->network.getType();
 
 		frame.netid = (neonetid_t)framemsg->network.getNetID();
-		frame.type = (neonettype_t)netType;
+		frame.type = (icsneo_msg_bus_type_t)netType;
 		frame.description = framemsg->description;
 		frame.length = framemsg->data.size();
 		frame.data = framemsg->data.data();
@@ -29,9 +29,9 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 		frame.status.transmitMessage = framemsg->transmitted;
 
 		switch(netType) {
-			case Network::Type::CAN:
-			case Network::Type::SWCAN:
-			case Network::Type::LSFTCAN: {
+			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: {
 				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 Network::Type::Ethernet: {
+			case _icsneo_msg_bus_type_t::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 Network::Type::LIN: {
+			case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
 				neomessage_lin_t& lin = *(neomessage_lin_t*)&neomsg;
 				auto linmsg = std::static_pointer_cast<LINMessage>(message);
 				if(!linmsg) { break; }
@@ -109,7 +109,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 		canerror.receiveErrorCount = canerrormsg->receiveErrorCount;
 		canerror.status.canBusOff = canerrormsg->busOff;
 		canerror.netid = (neonetid_t)canerrormsg->network.getNetID();
-		canerror.type = (neonettype_t)canerrormsg->network.getType();
+		canerror.type = (icsneo_msg_bus_type_t)canerrormsg->network.getType();
 		break;
 	}
 	default:
@@ -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 Network::Type::CAN:
-				case Network::Type::SWCAN:
-				case Network::Type::LSFTCAN: {
+				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: {
 					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 Network::Type::Ethernet: {
+				case _icsneo_msg_bus_type_t::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 Network::Type::LIN: {
+				case _icsneo_msg_bus_type_t::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/device.cpp b/device/device.cpp
index cfdec32..dadcceb 100644
--- a/device/device.cpp
+++ b/device/device.cpp
@@ -780,7 +780,7 @@ void Device::setWriteBlocks(bool blocks) {
 	com->setWriteBlocks(blocks);
 }
 
-size_t Device::getNetworkCountByType(Network::Type type) const {
+size_t Device::getNetworkCountByType(icsneo_msg_bus_type_t type) const {
 	size_t count = 0;
 	for(const auto& net : getSupportedRXNetworks())
 		if(net.getType() == type)
@@ -789,7 +789,7 @@ size_t Device::getNetworkCountByType(Network::Type type) const {
 }
 
 // Indexed starting at one
-Network Device::getNetworkByNumber(Network::Type type, size_t index) const {
+Network Device::getNetworkByNumber(icsneo_msg_bus_type_t type, size_t index) const {
 	size_t count = 0;
 	for(const auto& net : getSupportedRXNetworks()) {
 		if(net.getType() == type) {
diff --git a/device/extensions/flexray/extension.cpp b/device/extensions/flexray/extension.cpp
index 6e85bbf..46ca9d3 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<Frame>& frame, bool& success) {
-	if(!frame || frame->network.getType() != Network::Type::FlexRay)
+	if(!frame || frame->network.getType() != _icsneo_msg_bus_type_t::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 81408a3..e0ee662 100644
--- a/device/idevicesettings.cpp
+++ b/device/idevicesettings.cpp
@@ -403,7 +403,7 @@ int64_t IDeviceSettings::getBaudrateFor(Network net) const {
 	}
 
 	switch(net.getType()) {
-		case Network::Type::CAN: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::SWCAN: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::LSFTCAN: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::LIN: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::CAN: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::LSFTCAN: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::SWCAN: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::LIN: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::CAN: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::CAN: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::LIN: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::LIN: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::LIN: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::LIN: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::LIN: {
+		case _icsneo_msg_bus_type_t::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 Network::Type::LIN: {
+		case _icsneo_msg_bus_type_t::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 ca22333..f7e74d1 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 Network::Type::Ethernet:
+		case _icsneo_msg_bus_type_t::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/examples/cpp/a2b/src/a2b.cpp b/examples/cpp/a2b/src/a2b.cpp
index 9c3c9ca..3a9472f 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::Network::Type::A2B; })) {
+			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; })) {
 				return false;
 			}
 
-			if(std::none_of(rxNetworks.begin(), rxNetworks.end(), [](const icsneo::Network& net) { return net.getType() == icsneo::Network::Type::A2B; })) {
+			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; })) {
 				return false;
 			}
 
diff --git a/examples/cpp/interactive/src/InteractiveExample.cpp b/examples/cpp/interactive/src/InteractiveExample.cpp
index 4ee446b..263684d 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::Frame>(message);
 			switch(frame->network.getType()) {
-				case icsneo::Network::Type::CAN: {
+				case _icsneo_msg_bus_type_t::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::Network::Type::Ethernet: {
+				case _icsneo_msg_bus_type_t::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::Network::Type::ISO9141: {
+				case _icsneo_msg_bus_type_t::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 64002ab..400d374 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::Frame>(message);
-				if(icsneo::Network::Type::LIN == frame->network.getType()) {
+				if(_icsneo_msg_bus_type_t::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 5d64a98..5d14c7c 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::Frame>(message);
-				if(icsneo::Network::Type::MDIO == frame->network.getType()) {
+				if(_icsneo_msg_bus_type_t::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 7e5cdc6..0671aaf 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::Frame>(message);
 					switch(frame->network.getType()) {
-						case icsneo::Network::Type::CAN: {
+						case _icsneo_msg_bus_type_t::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::Network::Type::Ethernet: {
+						case _icsneo_msg_bus_type_t::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::Network::Type::ISO9141: {
+						case _icsneo_msg_bus_type_t::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 5967786..8404ed3 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::Frame>(msg);
-		if(frame->network.getType() == icsneo::Network::Type::CAN) {
+		if(frame->network.getType() == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can) {
 			++canFrameCount;
-		} else if(frame->network.getType() == icsneo::Network::Type::Ethernet) {
+		} else if(frame->network.getType() == _icsneo_msg_bus_type_t::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 7bc5941..0c86e7f 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(Network::Type::CAN), arbid(INVALID_ARBID) { messageType = Message::Type::Frame; }
-	CANMessageFilter(uint32_t arbid) : MessageFilter(Network::Type::CAN), arbid(arbid) { messageType = Message::Type::Frame; }
+	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; }
 
 	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 94d5892..3b0dbbe 100644
--- a/include/icsneo/communication/message/filter/messagefilter.h
+++ b/include/icsneo/communication/message/filter/messagefilter.h
@@ -14,10 +14,10 @@ public:
 	MessageFilter() {}
 	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(Network::Type type, Network::NetID net = Network::NetID::Any) : networkType(type), netid(net) {
+	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
 		// The NetID we want may be in there
-		includeInternalInAny = (networkType == Network::Type::Internal);
+		includeInternalInAny = (networkType == _icsneo_msg_bus_type_t::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 != Network::Type::Any) {
+		} else if (netid != Network::NetID::Any || networkType != _icsneo_msg_bus_type_t::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;
 	}
 
-	Network::Type networkType = Network::Type::Any;
-	bool matchNetworkType(Network::Type mtype) const {
-		if(networkType == Network::Type::Any && (mtype != Network::Type::Internal || includeInternalInAny))
+	icsneo_msg_bus_type_t networkType = _icsneo_msg_bus_type_t::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))
 			return true;
 		return networkType == mtype;
 	}
diff --git a/include/icsneo/communication/message/message.h b/include/icsneo/communication/message/message.h
index 259ce7a..a46a369 100644
--- a/include/icsneo/communication/message/message.h
+++ b/include/icsneo/communication/message/message.h
@@ -7,12 +7,20 @@ typedef uint16_t neomessagetype_t;
 #ifdef __cplusplus
 
 #include "icsneo/communication/network.h"
+#include "icsneo/icsneotypes.h"
 #include <vector>
 
 namespace icsneo {
 
-class Message {
+class AbstractMessage {
 public:
+	virtual const icsneo_msg_type_t getMsgType() const = 0;
+};
+
+class Message : public AbstractMessage {
+public:
+	virtual const icsneo_msg_type_t getMsgType() const { return icsneo_msg_type_device; }
+
 	enum class Type : neomessagetype_t {
 		Frame = 0,
 
@@ -56,6 +64,8 @@ public:
 	RawMessage(Network net) : Message(Message::Type::RawMessage), network(net) {}
 	RawMessage(Network net, std::vector<uint8_t> d) : Message(Message::Type::RawMessage), network(net), data(d) {}
 
+	virtual const icsneo_msg_type_t getMsgType() const { return icsneo_msg_type_internal; }
+
 	Network network;
 	std::vector<uint8_t> data;
 };
@@ -64,6 +74,10 @@ class Frame : public RawMessage {
 public:
 	Frame() : RawMessage(Message::Type::Frame) {}
 
+	const icsneo_msg_type_t getMsgType() const final { return icsneo_msg_type_bus; }
+
+	//virtual const icsneo_msg_bus_type_t getBusType() const = 0;
+
 	uint16_t description = 0;
 	bool transmitted = false;
 	bool error = false;
diff --git a/include/icsneo/communication/message/neomessage.h b/include/icsneo/communication/message/neomessage.h
index 9739e1a..d6c0574 100644
--- a/include/icsneo/communication/message/neomessage.h
+++ b/include/icsneo/communication/message/neomessage.h
@@ -115,7 +115,7 @@ typedef struct {
 	uint8_t _reserved1[16];
 	uint64_t timestamp;
 	uint64_t _reservedTimestamp;
-	uint8_t _reserved2[sizeof(size_t) * 2 + 7 + sizeof(neonetid_t) + sizeof(neonettype_t)];
+	uint8_t _reserved2[sizeof(size_t) * 2 + 7 + sizeof(neonetid_t) + sizeof(icsneo_msg_bus_type_t)];
 	neomessagetype_t messageType;
 	uint8_t _reserved3[12];
 } neomessage_t; // 72 bytes total
@@ -129,7 +129,7 @@ typedef struct {
 	size_t length;
 	uint8_t header[4];
 	neonetid_t netid;
-	neonettype_t type;
+	icsneo_msg_bus_type_t type;
 	uint8_t _reserved0;
 	uint16_t description;
 	neomessagetype_t messageType;
@@ -144,7 +144,7 @@ typedef struct {
 	size_t length;
 	uint32_t arbid;
 	neonetid_t netid;
-	neonettype_t type;
+	icsneo_msg_bus_type_t type;
 	uint8_t dlcOnWire;
 	uint16_t description;
 	neomessagetype_t messageType;
@@ -160,7 +160,7 @@ typedef struct {
 	uint8_t receiveErrorCount;
 	uint8_t _reserved3[5];
 	neonetid_t netid;
-	neonettype_t type;
+	icsneo_msg_bus_type_t type;
 	neomessagetype_t messageType;
 	uint8_t _reserved4[12];
 } neomessage_can_error_t;
@@ -174,7 +174,7 @@ typedef struct {
 	uint8_t preemptionFlags;
 	uint8_t _reservedHeader[3];
 	neonetid_t netid;
-	neonettype_t type;
+	icsneo_msg_bus_type_t type;
 	uint8_t _reserved0;
 	uint16_t description;
 	neomessagetype_t messageType;
@@ -200,7 +200,7 @@ typedef struct {
 	size_t length;
 	uint8_t header[4];
 	neonetid_t netid;
-	neonettype_t type;
+	icsneo_msg_bus_type_t type;
 	neomessage_linstatus_t linStatus;
 	uint16_t description;
 	neomessagetype_t messageType;
diff --git a/include/icsneo/communication/network.h b/include/icsneo/communication/network.h
index 2c4a11d..fce438f 100644
--- a/include/icsneo/communication/network.h
+++ b/include/icsneo/communication/network.h
@@ -2,9 +2,9 @@
 #define __NETWORKID_H_
 
 #include <stdint.h>
+#include <icsneo/icsneotypes.h>
 
 typedef uint16_t neonetid_t;
-typedef uint8_t neonettype_t;
 
 #ifdef __cplusplus
 
@@ -187,24 +187,6 @@ public:
 		Any = 0xfffe, // Never actually set as type, but used as flag for filtering
 		Invalid = 0xffff
 	};
-	enum class Type : neonettype_t {
-		Invalid = 0,
-		Internal = 1, // Used for statuses that don't actually need to be transferred to the client application
-		CAN = 2,
-		LIN = 3,
-		FlexRay = 4,
-		MOST = 5,
-		Ethernet = 6,
-		LSFTCAN = 7,
-		SWCAN = 8,
-		ISO9141 = 9,
-		I2C = 10,
-		A2B = 11,
-		SPI = 12,
-		MDIO = 13,
-		Any = 0xFE, // Never actually set as type, but used as flag for filtering
-		Other = 0xFF
-	};
 	enum class CoreMini : uint8_t {
 		HSCAN = 0,
 		MSCAN = 1,
@@ -307,37 +289,37 @@ public:
 		LIN15 = 99,
 		LIN16 = 100,
 	};
-	static const char* GetTypeString(Type type) {
+	static const char* GetTypeString(icsneo_msg_bus_type_t type) {
 		switch(type) {
-		case Type::CAN:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
 			return "CAN";
-		case Type::LIN:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin:
 			return "LIN";
-		case Type::FlexRay:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_flexray:
 			return "FlexRay";
-		case Type::MOST:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_most:
 			return "MOST";
-		case Type::Other:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_other:
 			return "Other";
-		case Type::Internal:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal:
 			return "Internal";
-		case Type::ISO9141:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141:
 			return "ISO 9141-2";
-		case Type::Ethernet:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet:
 			return "Ethernet";
-		case Type::LSFTCAN:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan:
 			return "Low Speed Fault Tolerant CAN";
-		case Type::SWCAN:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
 			return "Single Wire CAN";
-		case Type::I2C:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c:
 			return "I²C";
-		case Type::A2B:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b:
 			return "A2B";
-		case Type::SPI:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_spi:
 			return "SPI";
-		case Type::MDIO:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio:
 			return "MDIO";
-		case Type::Invalid:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_invalid:
 		default:
 			return "Invalid Type";
 		}
@@ -511,7 +493,7 @@ public:
 		}
 		return "Invalid VNET ID";
 	}
-	static Type GetTypeOfNetID(NetID netid, bool expand = true) {
+	static icsneo_msg_bus_type_t GetTypeOfNetID(NetID netid, bool expand = true) {
 		if(expand) {
 			netid = GetVnetAgnosticNetid((neonetid_t)netid).second;
 		}
@@ -533,7 +515,7 @@ public:
 		case NetID::DWCAN14:
 		case NetID::DWCAN15:
 		case NetID::DWCAN16:
-			return Type::CAN;
+			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can;
 		case NetID::LIN:
 		case NetID::LIN2:
 		case NetID::LIN3:
@@ -550,18 +532,18 @@ public:
 		case NetID::LIN14:
 		case NetID::LIN15:
 		case NetID::LIN16:
-			return Type::LIN;
+			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin;
 		case NetID::FlexRay:
 		case NetID::FlexRay1a:
 		case NetID::FlexRay1b:
 		case NetID::FlexRay2:
 		case NetID::FlexRay2a:
 		case NetID::FlexRay2b:
-			return Type::FlexRay;
+			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_flexray;
 		case NetID::MOST25:
 		case NetID::MOST50:
 		case NetID::MOST150:
-			return Type::MOST;
+			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_most;
 		case NetID::RED:
 		case NetID::RED_OLDFORMAT:
 		case NetID::Device:
@@ -583,10 +565,10 @@ public:
 		case NetID::RED_GET_RTC:
 		case NetID::DiskData:
 		case NetID::RED_App_Error:
-			return Type::Internal;
+			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal;
 		case NetID::Invalid:
 		case NetID::Any:
-			return Type::Invalid;
+			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_invalid;
 		case NetID::Ethernet:
 		case NetID::Ethernet_DAQ:
 		case NetID::Ethernet2:
@@ -607,26 +589,26 @@ public:
 		case NetID::OP_Ethernet14:
 		case NetID::OP_Ethernet15:
 		case NetID::OP_Ethernet16:
-			return Type::Ethernet;
+			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet;
 		case NetID::LSFTCAN:
 		case NetID::LSFTCAN2:
-			return Type::LSFTCAN;
+			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan;
 		case NetID::SWCAN:
 		case NetID::SWCAN2:
-			return Type::SWCAN;
+			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan;
 		case NetID::ISO9141:
 		case NetID::ISO9141_2:
 		case NetID::ISO9141_3:
 		case NetID::ISO9141_4:
-			return Type::ISO9141;
+			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141;
 		case NetID::I2C:
 		case NetID::I2C2:
 		case NetID::I2C3:
 		case NetID::I2C4:
-			return Type::I2C;
+			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c;
 		case NetID::A2B1:
 		case NetID::A2B2:
-			return Type::A2B;
+			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b;
 		case NetID::SPI1:
 		case NetID::SPI2:
 		case NetID::SPI3:
@@ -635,7 +617,7 @@ public:
 		case NetID::SPI6:
 		case NetID::SPI7:
 		case NetID::SPI8:
-			return Type::SPI;
+			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_spi;
 		case NetID::MDIO1:
 		case NetID::MDIO2:
 		case NetID::MDIO3:
@@ -644,9 +626,9 @@ public:
 		case NetID::MDIO6:
 		case NetID::MDIO7:
 		case NetID::MDIO8:
-			return Type::MDIO;
+			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio;
 		default:
-			return Type::Other;
+			return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_other;
 		}
 	}
 	static const char* GetNetIDString(NetID netid, bool expand = true) {
@@ -1386,7 +1368,7 @@ public:
 	Network(NetID netid) { setValue(netid); }
 	Network(CoreMini cm) { setValue(GetNetIDFromCoreMiniNetwork(cm)); }
 	NetID getNetID() const { return value; }
-	Type getType() const { return type; }
+	icsneo_msg_bus_type_t getType() const { return type; }
 	VnetId getVnetId() const { return vnetId; }
 	std::optional<CoreMini> getCoreMini() const { return GetCoreMiniNetworkFromNetID(getNetID()); }
 	friend std::ostream& operator<<(std::ostream& os, const Network& network) {
@@ -1398,7 +1380,7 @@ public:
 
 private:
 	NetID value; // Always use setValue so that value and type stay in sync
-	Type type;
+	icsneo_msg_bus_type_t type;
 	NetID commonNetId;
 	VnetId vnetId;
 	void setValue(NetID id, bool expand = true) {
diff --git a/include/icsneo/device/device.h b/include/icsneo/device/device.h
index 38634b2..9ba9bc2 100644
--- a/include/icsneo/device/device.h
+++ b/include/icsneo/device/device.h
@@ -226,8 +226,8 @@ public:
 		return std::find(supportedTXNetworks.begin(), supportedTXNetworks.end(), net) != supportedTXNetworks.end();
 	}
 
-	virtual size_t getNetworkCountByType(Network::Type) const;
-	virtual Network getNetworkByNumber(Network::Type, size_t) const;
+	virtual size_t getNetworkCountByType(icsneo_msg_bus_type_t) const;
+	virtual Network getNetworkByNumber(icsneo_msg_bus_type_t, size_t) const;
 
 	std::shared_ptr<HardwareInfo> getHardwareInfo(std::chrono::milliseconds timeout = std::chrono::milliseconds(100));
 
diff --git a/include/icsneo/icsneoc.h b/include/icsneo/icsneoc.h
index f371110..46b4023 100644
--- a/include/icsneo/icsneoc.h
+++ b/include/icsneo/icsneoc.h
@@ -313,7 +313,7 @@ extern bool DLLExport icsneo_removeMessageCallback(const neodevice_t* device, in
  * device. For instance, on a ValueCAN 4-2, the second CAN network is ICSNEO_NETID_HSCAN2, while
  * on a neoVI FIRE the second CAN network is ICSNEO_NETID_MSCAN.
  */
-extern neonetid_t DLLExport icsneo_getNetworkByNumber(const neodevice_t* device, neonettype_t type, unsigned int number);
+extern neonetid_t DLLExport icsneo_getNetworkByNumber(const neodevice_t* device, icsneo_msg_bus_type_t type, unsigned int number);
 
 /**
  * \brief Get the friendly product name for a specified device.
@@ -908,7 +908,7 @@ fn_icsneo_addMessageCallback icsneo_addMessageCallback;
 typedef bool(*fn_icsneo_removeMessageCallback)(const neodevice_t* device, int id);
 fn_icsneo_removeMessageCallback icsneo_removeMessageCallback;
 
-typedef neonetid_t (*fn_icsneo_getNetworkByNumber)(const neodevice_t* device, neonettype_t type, unsigned int number);
+typedef neonetid_t (*fn_icsneo_getNetworkByNumber)(const neodevice_t* device, icsneo_msg_bus_type_t type, unsigned int number);
 fn_icsneo_getNetworkByNumber icsneo_getNetworkByNumber;
 
 typedef bool(*fn_icsneo_getProductName)(const neodevice_t* device, char* str, size_t* maxLength);
diff --git a/include/icsneo/icsneocpp.h b/include/icsneo/icsneocpp.h
index 62134fc..6c463a9 100644
--- a/include/icsneo/icsneocpp.h
+++ b/include/icsneo/icsneocpp.h
@@ -6,6 +6,7 @@
 #include <vector>
 #include <memory>
 
+#include "icsneo/icsneotypes.h"
 #include "icsneo/device/device.h"
 #include "icsneo/api/version.h"
 #include "icsneo/api/eventmanager.h"
diff --git a/include/icsneo/icsneotypes.h b/include/icsneo/icsneotypes.h
index f3508e8..244ea11 100644
--- a/include/icsneo/icsneotypes.h
+++ b/include/icsneo/icsneotypes.h
@@ -165,6 +165,49 @@ _Static_assert(sizeof(_icsneo_devicetype_t) <= sizeof(icsneo_devicetype_t), "ics
 static_assert(sizeof(_icsneo_devicetype_t) <= sizeof(icsneo_devicetype_t));
 #endif
 
+typedef enum _icsneo_msg_type_t {
+    icsneo_msg_type_device,
+    icsneo_msg_type_internal,
+    icsneo_msg_type_bus,
+
+    icsneo_msg_type_maxsize,
+} _icsneo_msg_type_t;
+
+/** @brief Integer representation of _icsneo_msg_type_t enum. 
+ * 
+ * This is used for easier ABI compatibility, especially between other languages.
+ */
+typedef uint32_t icsneo_msg_type_t;
+
+
+/** @brief
+ * Bus message types, useful for filtering out or identifying Bus Messages.
+*/
+typedef enum _icsneo_msg_bus_type_t {
+    icsneo_msg_bus_type_invalid = 0,
+    icsneo_msg_bus_type_internal = 1, // Used for statuses that don't actually need to be transferred to the client application
+    icsneo_msg_bus_type_can = 2,
+    icsneo_msg_bus_type_lin = 3,
+    icsneo_msg_bus_type_flexray = 4,
+    icsneo_msg_bus_type_most = 5,
+    icsneo_msg_bus_type_ethernet = 6,
+    icsneo_msg_bus_type_lsftcan = 7,
+    icsneo_msg_bus_type_swcan = 8,
+    icsneo_msg_bus_type_iso9141 = 9,
+    icsneo_msg_bus_type_i2c = 10,
+    icsneo_msg_bus_type_a2b = 11,
+    icsneo_msg_bus_type_spi = 12,
+    icsneo_msg_bus_type_mdio = 13,
+    icsneo_msg_bus_type_any = 0xFE, // Never actually set as type, but used as flag for filtering
+    icsneo_msg_bus_type_other = 0xFF
+} _icsneo_msg_bus_type_t;
+
+/** @brief Integer representation of _icsneo_msg_bus_type_t enum. 
+ * 
+ * This is used for easier ABI compatibility, especially between other languages.
+ */
+typedef uint8_t icsneo_msg_bus_type_t;
+
 #ifdef __cplusplus
 }
 #endif