diff --git a/doc/message_dispatching.png b/doc/message_dispatching.png
new file mode 100644
index 000000000..c42187867
Binary files /dev/null and b/doc/message_dispatching.png differ
diff --git a/doc/message_dispatching.puml b/doc/message_dispatching.puml
new file mode 100644
index 000000000..8e6406654
--- /dev/null
+++ b/doc/message_dispatching.puml
@@ -0,0 +1,51 @@
+
+@startuml
+
+interface MessageDispatcherInterface {
+    +dispatch_call(const json& call, bool triggered = false)
+    +dispatch_call_async(const json& call, bool triggered = false): std::future<EnhancedMessage<T>>
+    +dispatch_call_result(const json& call_result)
+    +dispatch_call_error(const json& call_error)
+}
+
+class v16::MessageDispatcher {
+    - MessageQueue& message_queue
+    - ChargePointConfiguration& configuration
+    - RegistrationStatus& registration_status
+}
+
+class v201::MessageDispatcher {
+    - MessageQueue& message_queue
+    - DeviceModel& device_model
+    - ConnectivityManager& connectivity_manager
+    - RegistrationStatusEnum& registration_status
+}
+
+interface v201::DataTransferInterface {
+    +data_transfer_req(request: DataTransferRequest): std::optional<DataTransferResponse>
+    +handle_data_transfer_req(call: Call<DataTransferRequest>)
+}
+
+class v201::DataTransfer {
+    -MessageDispatcherInterface &message_dispatcher
+    -std::optional<std::function<DataTransferResponse(DataTransferRequest)>> data_transfer_callback
+}
+
+class v201::ChargePoint {
+    std::unique_ptr<MessageDispatcherInterface> message_dispatcher;
+    std::unique_ptr<v201::DataTransferInterface> data_transfer;
+}
+
+class v16::ChargePoint {
+    std::unique_ptr<MessageDispatcherInterface> message_dispatcher;
+}
+
+MessageDispatcherInterface <|-- v16::MessageDispatcher  
+MessageDispatcherInterface <|-- v201::MessageDispatcher
+v201::DataTransferInterface <|-- v201::DataTransfer
+MessageDispatcherInterface *-- v201::DataTransfer
+MessageDispatcherInterface *-- v201::ChargePoint
+v201::DataTransferInterface *-- v201::ChargePoint
+MessageDispatcherInterface *-- v16::ChargePoint
+
+@enduml
\ No newline at end of file
diff --git a/include/ocpp/common/constants.hpp b/include/ocpp/common/constants.hpp
index 93a0eca9e..59fb9db21 100644
--- a/include/ocpp/common/constants.hpp
+++ b/include/ocpp/common/constants.hpp
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <chrono>
 #include <cstdint>
 
 namespace ocpp {
@@ -22,4 +23,6 @@ constexpr float NO_LIMIT_SPECIFIED = -1.0;
 constexpr std::int32_t NO_START_PERIOD = -1;
 constexpr std::int32_t EVSEID_NOT_SET = -1;
 
+constexpr std::chrono::seconds DEFAULT_WAIT_FOR_FUTURE_TIMEOUT = std::chrono::seconds(60);
+
 } // namespace ocpp
\ No newline at end of file
diff --git a/include/ocpp/common/message_dispatcher.hpp b/include/ocpp/common/message_dispatcher.hpp
new file mode 100644
index 000000000..ab479d19c
--- /dev/null
+++ b/include/ocpp/common/message_dispatcher.hpp
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+
+#pragma once
+
+#include <ocpp/common/message_queue.hpp>
+
+namespace ocpp {
+
+/// \brief Interface for dispatching OCPP messages that shall be send over the websocket. This interface defines
+/// dispatching of Call, CallResult and CallError messages.
+/// \tparam T Type specifies the OCPP protocol version
+template <typename T> class MessageDispatcherInterface {
+
+public:
+    virtual ~MessageDispatcherInterface(){};
+
+    /// \brief Dispatches a Call message.
+    /// \param call the OCPP Call message.
+    /// \param triggered indicates if the call was triggered by a TriggerMessage. Default is false.
+    virtual void dispatch_call(const json& call, bool triggered = false) = 0;
+
+    /// \brief Dispatches a Call message asynchronously.
+    /// \param call the OCPP Call message.
+    /// \param triggered indicates if the call was triggered by a TriggerMessage. Default is false.
+    /// \return std::future<ocpp::EnhancedMessage<T>> Future object containing the enhanced message
+    ///         result of type T.
+    virtual std::future<ocpp::EnhancedMessage<T>> dispatch_call_async(const json& call, bool triggered = false) = 0;
+
+    /// \brief Dispatches a CallResult message.
+    /// \param call_result the OCPP CallResult message.
+    virtual void dispatch_call_result(const json& call_result) = 0;
+
+    /// \brief Dispatches a CallError message.
+    /// \param call_result the OCPP CallError message.
+    virtual void dispatch_call_error(const json& call_error) = 0;
+};
+
+} // namespace ocpp
\ No newline at end of file
diff --git a/include/ocpp/common/message_queue.hpp b/include/ocpp/common/message_queue.hpp
index 1d56ee47c..63dc0e59c 100644
--- a/include/ocpp/common/message_queue.hpp
+++ b/include/ocpp/common/message_queue.hpp
@@ -630,16 +630,7 @@ template <typename M> class MessageQueue {
         }
     }
 
-    /// \brief pushes a new \p call message onto the message queue
-    template <class T> void push(Call<T> call, const bool stall_until_accepted = false) {
-        if (!running) {
-            return;
-        }
-        json call_json = call;
-        push(call_json, stall_until_accepted);
-    }
-
-    void push(const json& message, const bool stall_until_accepted = false) {
+    void push_call(const json& message, const bool stall_until_accepted = false) {
         if (!running) {
             return;
         }
@@ -664,16 +655,15 @@ template <typename M> class MessageQueue {
     }
 
     /// \brief Sends a new \p call_result message over the websocket
-    template <class T> void push(CallResult<T> call_result) {
+    void push_call_result(const json& call_result) {
         if (!running) {
             return;
         }
-
         this->send_callback(call_result);
         {
             std::lock_guard<std::recursive_mutex> lk(this->next_message_mutex);
             if (next_message_to_send.has_value()) {
-                if (next_message_to_send.value() == call_result.uniqueId) {
+                if (next_message_to_send.value() == call_result.at(MESSAGE_ID)) {
                     next_message_to_send.reset();
                 }
             }
@@ -683,7 +673,7 @@ template <typename M> class MessageQueue {
     }
 
     /// \brief Sends a new \p call_error message over the websocket
-    void push(CallError call_error) {
+    void push_call_error(CallError call_error) {
         if (!running) {
             return;
         }
@@ -703,7 +693,7 @@ template <typename M> class MessageQueue {
 
     /// \brief pushes a new \p call message onto the message queue
     /// \returns a future from which the CallResult can be extracted
-    template <class T> std::future<EnhancedMessage<M>> push_async(Call<T> call) {
+    std::future<EnhancedMessage<M>> push_call_async(const json& call) {
         auto message = std::make_shared<ControlMessage<M>>(call);
 
         if (!running) {
diff --git a/include/ocpp/v16/charge_point_impl.hpp b/include/ocpp/v16/charge_point_impl.hpp
index bcb31bdd2..0f79a59d9 100644
--- a/include/ocpp/v16/charge_point_impl.hpp
+++ b/include/ocpp/v16/charge_point_impl.hpp
@@ -16,6 +16,7 @@
 
 #include <ocpp/common/aligned_timer.hpp>
 #include <ocpp/common/charging_station_base.hpp>
+#include <ocpp/common/message_dispatcher.hpp>
 #include <ocpp/common/message_queue.hpp>
 #include <ocpp/common/schemas.hpp>
 #include <ocpp/common/types.hpp>
@@ -23,6 +24,7 @@
 #include <ocpp/v16/charge_point_configuration.hpp>
 #include <ocpp/v16/connector.hpp>
 #include <ocpp/v16/database_handler.hpp>
+#include <ocpp/v16/message_dispatcher.hpp>
 #include <ocpp/v16/messages/Authorize.hpp>
 #include <ocpp/v16/messages/BootNotification.hpp>
 #include <ocpp/v16/messages/CancelReservation.hpp>
@@ -87,7 +89,7 @@ class ChargePointImpl : ocpp::ChargingStationBase {
     BootReasonEnum bootreason;
     ChargePointConnectionState connection_state;
     bool boot_notification_callerror;
-    RegistrationStatus registration_status;
+    std::atomic<RegistrationStatus> registration_status;
     DiagnosticsStatus diagnostics_status;
     FirmwareStatus firmware_status;
     bool firmware_update_is_pending = false;
@@ -95,6 +97,7 @@ class ChargePointImpl : ocpp::ChargingStationBase {
     std::string message_log_path;
 
     std::unique_ptr<Websocket> websocket;
+    std::unique_ptr<ocpp::MessageDispatcherInterface<MessageType>> message_dispatcher;
     Everest::SteadyTimer websocket_timer;
     std::unique_ptr<MessageQueue<v16::MessageType>> message_queue;
     std::map<int32_t, std::shared_ptr<Connector>> connectors;
@@ -205,11 +208,6 @@ class ChargePointImpl : ocpp::ChargingStationBase {
     std::unique_ptr<ocpp::MessageQueue<v16::MessageType>> create_message_queue();
     void message_callback(const std::string& message);
     void handle_message(const EnhancedMessage<v16::MessageType>& message);
-    template <class T> bool send(Call<T> call, bool initiated_by_trigger_message = false);
-    template <class T>
-    std::future<EnhancedMessage<v16::MessageType>> send_async(Call<T> call, bool initiated_by_trigger_message = false);
-    template <class T> bool send(CallResult<T> call_result);
-    bool send(CallError call_error);
     void heartbeat(bool initiated_by_trigger_message = false);
     void boot_notification(bool initiated_by_trigger_message = false);
     void clock_aligned_meter_values_sample();
diff --git a/include/ocpp/v16/message_dispatcher.hpp b/include/ocpp/v16/message_dispatcher.hpp
new file mode 100644
index 000000000..5c82e2234
--- /dev/null
+++ b/include/ocpp/v16/message_dispatcher.hpp
@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+
+#pragma once
+
+#include <ocpp/common/message_dispatcher.hpp>
+#include <ocpp/v16/charge_point_configuration.hpp>
+
+namespace ocpp {
+namespace v16 {
+
+class MessageDispatcher : public MessageDispatcherInterface<MessageType> {
+
+public:
+    MessageDispatcher(ocpp::MessageQueue<MessageType>& message_queue, ChargePointConfiguration& configuration,
+                      std::atomic<RegistrationStatus>& registration_status) :
+        message_queue(message_queue), configuration(configuration), registration_status(registration_status){};
+    void dispatch_call(const json& call, bool triggered = false) override;
+    std::future<ocpp::EnhancedMessage<MessageType>> dispatch_call_async(const json& call, bool triggered) override;
+    void dispatch_call_result(const json& call_result) override;
+    void dispatch_call_error(const json& call_error) override;
+
+private:
+    ocpp::MessageQueue<MessageType>& message_queue;
+    ChargePointConfiguration& configuration;
+    std::atomic<RegistrationStatus>& registration_status;
+};
+
+} // namespace v16
+} // namespace ocpp
\ No newline at end of file
diff --git a/include/ocpp/v201/charge_point.hpp b/include/ocpp/v201/charge_point.hpp
index 35a963e3a..2ed41a608 100644
--- a/include/ocpp/v201/charge_point.hpp
+++ b/include/ocpp/v201/charge_point.hpp
@@ -7,6 +7,8 @@
 #include <memory>
 #include <set>
 
+#include <ocpp/common/message_dispatcher.hpp>
+
 #include <ocpp/common/charging_station_base.hpp>
 
 #include <ocpp/v201/average_meter_values.hpp>
@@ -373,6 +375,8 @@ class ChargePoint : public ChargePointInterface, private ocpp::ChargingStationBa
     std::unique_ptr<EvseManager> evse_manager;
     std::unique_ptr<ConnectivityManager> connectivity_manager;
 
+    std::unique_ptr<MessageDispatcherInterface<MessageType>> message_dispatcher;
+
     // utility
     std::shared_ptr<MessageQueue<v201::MessageType>> message_queue;
     std::shared_ptr<DatabaseHandler> database_handler;
@@ -401,7 +405,7 @@ class ChargePoint : public ChargePointInterface, private ocpp::ChargingStationBa
     std::atomic_bool stop_auth_cache_cleanup_handler;
 
     // states
-    RegistrationStatusEnum registration_status;
+    std::atomic<RegistrationStatusEnum> registration_status;
     FirmwareStatusEnum firmware_status;
     // The request ID in the last firmware update status received
     std::optional<int32_t> firmware_status_id;
@@ -453,8 +457,6 @@ class ChargePoint : public ChargePointInterface, private ocpp::ChargingStationBa
     /// \brief optional delay to resumption of message queue after reconnecting to the CSMS
     std::chrono::seconds message_queue_resume_delay = std::chrono::seconds(0);
 
-    bool send(CallError call_error);
-
     // internal helper functions
     void initialize(const std::map<int32_t, int32_t>& evse_connector_structure, const std::string& message_log_path);
     void init_certificate_expiration_check_timers();
@@ -748,20 +750,13 @@ class ChargePoint : public ChargePointInterface, private ocpp::ChargingStationBa
     // Functional Block P: DataTransfer
     void handle_data_transfer_req(Call<DataTransferRequest> call);
 
-    // general message handling
-    template <class T> bool send(ocpp::Call<T> call, const bool initiated_by_trigger_message = false);
-
-    template <class T> std::future<EnhancedMessage<v201::MessageType>> send_async(ocpp::Call<T> call);
-
-    template <class T> bool send(ocpp::CallResult<T> call_result);
-
     // Generates async sending callbacks
     template <class RequestType, class ResponseType>
     std::function<ResponseType(RequestType)> send_callback(MessageType expected_response_message_type) {
         return [this, expected_response_message_type](auto request) {
             MessageId message_id = MessageId(to_string(this->uuid_generator()));
             const auto enhanced_response =
-                this->send_async<RequestType>(ocpp::Call<RequestType>(request, message_id)).get();
+                this->message_dispatcher->dispatch_call_async(ocpp::Call<RequestType>(request, message_id)).get();
             if (enhanced_response.messageType != expected_response_message_type) {
                 throw UnexpectedMessageTypeFromCSMS(
                     std::string("Got unexpected message type from CSMS, expected: ") +
diff --git a/include/ocpp/v201/message_dispatcher.hpp b/include/ocpp/v201/message_dispatcher.hpp
new file mode 100644
index 000000000..a0ff42a5e
--- /dev/null
+++ b/include/ocpp/v201/message_dispatcher.hpp
@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+
+#pragma once
+
+#include <ocpp/common/message_dispatcher.hpp>
+#include <ocpp/v201/connectivity_manager.hpp>
+#include <ocpp/v201/device_model.hpp>
+
+namespace ocpp {
+namespace v201 {
+
+class MessageDispatcher : public MessageDispatcherInterface<MessageType> {
+
+public:
+    MessageDispatcher(ocpp::MessageQueue<MessageType>& message_queue, DeviceModel& device_model,
+                      std::atomic<RegistrationStatusEnum>& registration_status) :
+        message_queue(message_queue), device_model(device_model), registration_status(registration_status){};
+    void dispatch_call(const json& call, bool triggered = false) override;
+    std::future<ocpp::EnhancedMessage<MessageType>> dispatch_call_async(const json& call, bool triggered) override;
+    void dispatch_call_result(const json& call_result) override;
+    void dispatch_call_error(const json& call_error) override;
+
+private:
+    ocpp::MessageQueue<MessageType>& message_queue;
+    DeviceModel& device_model;
+    std::atomic<RegistrationStatusEnum>& registration_status;
+};
+
+} // namespace v201
+} // namespace ocpp
\ No newline at end of file
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 246a53f4f..9653406bc 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -38,6 +38,7 @@ if(LIBOCPP_ENABLE_V16)
             ocpp/v16/charge_point.cpp
             ocpp/v16/database_handler.cpp
             ocpp/v16/charge_point_impl.cpp
+            ocpp/v16/message_dispatcher.cpp
             ocpp/v16/smart_charging.cpp
             ocpp/v16/charge_point_configuration.cpp
             ocpp/v16/charge_point_state_machine.cpp
@@ -80,6 +81,7 @@ if(LIBOCPP_ENABLE_V201)
             ocpp/v201/utils.cpp
             ocpp/v201/component_state_manager.cpp
             ocpp/v201/connectivity_manager.cpp
+            ocpp/v201/message_dispatcher.cpp
     )
     add_subdirectory(ocpp/v201/messages)
 endif()
diff --git a/lib/ocpp/v16/charge_point_impl.cpp b/lib/ocpp/v16/charge_point_impl.cpp
index 639d3c33a..0c9501f69 100644
--- a/lib/ocpp/v16/charge_point_impl.cpp
+++ b/lib/ocpp/v16/charge_point_impl.cpp
@@ -6,6 +6,7 @@
 #include <thread>
 
 #include <everest/logging.hpp>
+#include <ocpp/common/constants.hpp>
 #include <ocpp/common/websocket/websocket.hpp>
 #include <ocpp/v16/charge_point.hpp>
 #include <ocpp/v16/charge_point_configuration.hpp>
@@ -32,7 +33,6 @@ const auto INITIAL_CERTIFICATE_REQUESTS_DELAY = std::chrono::seconds(60);
 const auto WEBSOCKET_INIT_DELAY = std::chrono::seconds(2);
 const auto DEFAULT_MESSAGE_QUEUE_SIZE_THRESHOLD = 2E5;
 const auto DEFAULT_BOOT_NOTIFICATION_INTERVAL_S = 60; // fallback interval if BootNotification returns interval of 0.
-const auto DEFAULT_WAIT_FOR_FUTURE_TIMEOUT = std::chrono::seconds(60);
 const auto DEFAULT_PRICE_NUMBER_OF_DECIMALS = 3;
 
 ChargePointImpl::ChargePointImpl(const std::string& config, const fs::path& share_path,
@@ -60,6 +60,8 @@ ChargePointImpl::ChargePointImpl(const std::string& config, const fs::path& shar
     this->transaction_handler = std::make_unique<TransactionHandler>(this->configuration->getNumberOfConnectors());
     this->external_notify = {v16::MessageType::StartTransactionResponse};
     this->message_queue = this->create_message_queue();
+    this->message_dispatcher =
+        std::make_unique<MessageDispatcher>(*this->message_queue, *this->configuration, this->registration_status);
     auto log_formats = this->configuration->getLogMessagesFormat();
     bool log_to_console = std::find(log_formats.begin(), log_formats.end(), "console") != log_formats.end();
     bool detailed_log_to_console =
@@ -417,7 +419,7 @@ void ChargePointImpl::heartbeat(bool initiated_by_trigger_message) {
     HeartbeatRequest req;
 
     ocpp::Call<HeartbeatRequest> call(req, this->message_queue->createMessageId());
-    this->send<HeartbeatRequest>(call, initiated_by_trigger_message);
+    this->message_dispatcher->dispatch_call(call, initiated_by_trigger_message);
 }
 
 void ChargePointImpl::boot_notification(bool initiated_by_trigger_message) {
@@ -434,7 +436,7 @@ void ChargePointImpl::boot_notification(bool initiated_by_trigger_message) {
     req.meterType = this->configuration->getMeterType();
 
     ocpp::Call<BootNotificationRequest> call(req, this->message_queue->createMessageId());
-    this->send<BootNotificationRequest>(call, initiated_by_trigger_message);
+    this->message_dispatcher->dispatch_call(call, initiated_by_trigger_message);
 }
 
 void ChargePointImpl::clock_aligned_meter_values_sample() {
@@ -975,7 +977,7 @@ void ChargePointImpl::send_meter_value(int32_t connector, MeterValue meter_value
     req.meterValue.push_back(meter_value);
 
     ocpp::Call<MeterValuesRequest> call(req, message_id);
-    this->send<MeterValuesRequest>(call, initiated_by_trigger_message);
+    this->message_dispatcher->dispatch_call(call, initiated_by_trigger_message);
 }
 
 void ChargePointImpl::send_meter_value_on_pricing_trigger(const int32_t connector_number,
@@ -1116,6 +1118,8 @@ bool ChargePointImpl::restart(const std::map<int, ChargePointStatus>& connector_
         this->database_handler->open_connection();
         // instantiating new message queue on restart
         this->message_queue = this->create_message_queue();
+        this->message_dispatcher =
+            std::make_unique<MessageDispatcher>(*this->message_queue, *this->configuration, this->registration_status);
         return this->start(connector_status_map, bootreason, {});
     } else {
         EVLOG_warning << "Attempting to restart Chargepoint while it has not been stopped before";
@@ -1257,10 +1261,11 @@ void ChargePointImpl::message_callback(const std::string& message) {
         enhanced_message = this->message_queue->receive(message);
     } catch (const TimePointParseException& e) {
         EVLOG_error << "Exception during handling of message: " << e.what();
-        this->send(CallError(enhanced_message.uniqueId, "FormationViolation", e.what(), json({})));
+        this->message_dispatcher->dispatch_call_error(
+            CallError(enhanced_message.uniqueId, "FormationViolation", e.what(), json({})));
     } catch (const json::exception& e) {
         EVLOG_error << "JSON exception during reception of message: " << e.what();
-        this->send(CallError(MessageId("-1"), "GenericError", e.what(), json({})));
+        this->message_dispatcher->dispatch_call_error(CallError(MessageId("-1"), "GenericError", e.what(), json({})));
         return;
     }
 
@@ -1273,7 +1278,7 @@ void ChargePointImpl::message_callback(const std::string& message) {
             // FIXME(kai): however, only send a CALLERROR when it is a CALL message we just received
             if (enhanced_message.messageTypeId == MessageTypeId::CALL) {
                 auto call_error = CallError(enhanced_message.uniqueId, "NotSupported", "", json({}, true));
-                this->send(call_error);
+                this->message_dispatcher->dispatch_call_error(call_error);
             } else if (enhanced_message.messageTypeId == MessageTypeId::CALLERROR) {
                 EVLOG_error << "Received a CALLERROR in response to a "
                             << conversions::messagetype_to_string(enhanced_message.messageType) << ": " << message;
@@ -1316,13 +1321,13 @@ void ChargePointImpl::message_callback(const std::string& message) {
                     response.status = RemoteStartStopStatus::Rejected;
                     const ocpp::CallResult<RemoteStartTransactionResponse> call_result(response,
                                                                                        enhanced_message.uniqueId);
-                    this->send<RemoteStartTransactionResponse>(call_result);
+                    this->message_dispatcher->dispatch_call_result(call_result);
                 } else if (enhanced_message.messageType == MessageType::RemoteStopTransaction) {
                     RemoteStopTransactionResponse response;
                     response.status = RemoteStartStopStatus::Rejected;
                     const ocpp::CallResult<RemoteStopTransactionResponse> call_result(response,
                                                                                       enhanced_message.uniqueId);
-                    this->send<RemoteStopTransactionResponse>(call_result);
+                    this->message_dispatcher->dispatch_call_result(call_result);
                 } else {
                     this->handle_message(enhanced_message);
                 }
@@ -1342,14 +1347,14 @@ void ChargePointImpl::message_callback(const std::string& message) {
         EVLOG_error << "JSON exception during handling of message: " << e.what();
         if (json_message.is_array() && json_message.size() > MESSAGE_ID) {
             auto call_error = CallError(enhanced_message.uniqueId, "FormationViolation", e.what(), json({}, true));
-            this->send(call_error);
+            this->message_dispatcher->dispatch_call_error(call_error);
             this->securityEventNotification(ocpp::security_events::INVALIDMESSAGES,
                                             std::optional<CiString<255>>(message), true);
         }
     } catch (const EnumConversionException& e) {
         EVLOG_error << "EnumConversionException during handling of message: " << e.what();
         auto call_error = CallError(enhanced_message.uniqueId, "FormationViolation", e.what(), json({}, true));
-        this->send(call_error);
+        this->message_dispatcher->dispatch_call_error(call_error);
         this->securityEventNotification(ocpp::security_events::INVALIDMESSAGES, std::optional<CiString<255>>(message),
                                         true);
     }
@@ -1663,7 +1668,7 @@ void ChargePointImpl::handleChangeAvailabilityRequest(ocpp::Call<ChangeAvailabil
 
     // respond first
     ocpp::CallResult<ChangeAvailabilityResponse> call_result(response, call.uniqueId);
-    this->send<ChangeAvailabilityResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     // if scheduled: execute status transition for connector 0
     // if accepted: execute status transition for connector 0 and other connectors
@@ -1704,7 +1709,7 @@ void ChargePointImpl::handleChangeConfigurationRequest(ocpp::Call<ChangeConfigur
                         EVLOG_info
                             << "AuthorizationKey was changed while on security profile 1 or 2. Reconnect Websocket.";
                         ocpp::CallResult<ChangeConfigurationResponse> call_result(response, call.uniqueId);
-                        this->send<ChangeConfigurationResponse>(call_result);
+                        this->message_dispatcher->dispatch_call_result(call_result);
                         responded = true;
                         this->websocket->reconnect(1000);
                     } else {
@@ -1739,7 +1744,7 @@ void ChargePointImpl::handleChangeConfigurationRequest(ocpp::Call<ChangeConfigur
                         } else {
                             // valid set of security profile
                             ocpp::CallResult<ChangeConfigurationResponse> call_result(response, call.uniqueId);
-                            this->send<ChangeConfigurationResponse>(call_result);
+                            this->message_dispatcher->dispatch_call_result(call_result);
                             int32_t security_profile = std::stoi(call.msg.value);
                             responded = true;
                             this->switch_security_profile_callback = [this, security_profile]() {
@@ -1794,7 +1799,7 @@ void ChargePointImpl::handleChangeConfigurationRequest(ocpp::Call<ChangeConfigur
 
     if (!responded) {
         ocpp::CallResult<ChangeConfigurationResponse> call_result(response, call.uniqueId);
-        this->send<ChangeConfigurationResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
     }
 
     if (this->configuration_key_changed_callbacks.count(call.msg.key) and
@@ -1845,7 +1850,7 @@ void ChargePointImpl::handleClearCacheRequest(ocpp::Call<ClearCacheRequest> call
         } catch (QueryExecutionException& e) {
             auto call_error = CallError(call.uniqueId, "InternalError",
                                         "Database error while clearing authorization cache", json({}, true));
-            this->send(call_error);
+            this->message_dispatcher->dispatch_call_error(call_error);
             return;
         }
     } else {
@@ -1853,7 +1858,7 @@ void ChargePointImpl::handleClearCacheRequest(ocpp::Call<ClearCacheRequest> call
     }
 
     ocpp::CallResult<ClearCacheResponse> call_result(response, call.uniqueId);
-    this->send<ClearCacheResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePointImpl::handleDataTransferRequest(ocpp::Call<DataTransferRequest> call) {
@@ -1901,7 +1906,7 @@ void ChargePointImpl::handleDataTransferRequest(ocpp::Call<DataTransferRequest>
     }
 
     ocpp::CallResult<DataTransferResponse> call_result(response, call.uniqueId);
-    this->send<DataTransferResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePointImpl::handleGetConfigurationRequest(ocpp::Call<GetConfigurationRequest> call) {
@@ -1909,7 +1914,7 @@ void ChargePointImpl::handleGetConfigurationRequest(ocpp::Call<GetConfigurationR
 
     const auto response = this->get_configuration_key(call.msg);
     ocpp::CallResult<GetConfigurationResponse> call_result(response, call.uniqueId);
-    this->send<GetConfigurationResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePointImpl::handleRemoteStartTransactionRequest(ocpp::Call<RemoteStartTransactionRequest> call) {
@@ -1925,7 +1930,7 @@ void ChargePointImpl::handleRemoteStartTransactionRequest(ocpp::Call<RemoteStart
             EVLOG_warning << "Received RemoteStartTransactionRequest with connector id <= 0";
             response.status = RemoteStartStopStatus::Rejected;
             ocpp::CallResult<RemoteStartTransactionResponse> call_result(response, call.uniqueId);
-            this->send<RemoteStartTransactionResponse>(call_result);
+            this->message_dispatcher->dispatch_call_result(call_result);
             return;
         }
         referenced_connectors.push_back(call.msg.connectorId.value());
@@ -1969,7 +1974,7 @@ void ChargePointImpl::handleRemoteStartTransactionRequest(ocpp::Call<RemoteStart
         EVLOG_debug << "Received RemoteStartTransactionRequest for reserved connector and rejected";
         response.status = RemoteStartStopStatus::Rejected;
         ocpp::CallResult<RemoteStartTransactionResponse> call_result(response, call.uniqueId);
-        this->send<RemoteStartTransactionResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
         return;
     }
 
@@ -1988,7 +1993,7 @@ void ChargePointImpl::handleRemoteStartTransactionRequest(ocpp::Call<RemoteStart
         } else {
             response.status = RemoteStartStopStatus::Rejected;
             ocpp::CallResult<RemoteStartTransactionResponse> call_result(response, call.uniqueId);
-            this->send<RemoteStartTransactionResponse>(call_result);
+            this->message_dispatcher->dispatch_call_result(call_result);
             return;
         }
     }
@@ -2006,7 +2011,7 @@ void ChargePointImpl::handleRemoteStartTransactionRequest(ocpp::Call<RemoteStart
 
         response.status = RemoteStartStopStatus::Accepted;
         ocpp::CallResult<RemoteStartTransactionResponse> call_result(response, call.uniqueId);
-        this->send<RemoteStartTransactionResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
 
         if (this->configuration->getAuthorizeRemoteTxRequests()) {
             this->provide_token_callback(call.msg.idTag.get(), referenced_connectors, false);
@@ -2059,7 +2064,7 @@ void ChargePointImpl::handleRemoteStopTransactionRequest(ocpp::Call<RemoteStopTr
     }
 
     ocpp::CallResult<RemoteStopTransactionResponse> call_result(response, call.uniqueId);
-    this->send<RemoteStopTransactionResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (connector > 0) {
         this->stop_transaction_callback(connector, Reason::Remote);
@@ -2082,7 +2087,7 @@ void ChargePointImpl::handleResetRequest(ocpp::Call<ResetRequest> call) {
 
     // send response
     ocpp::CallResult<ResetResponse> call_result(response, call.uniqueId);
-    this->send<ResetResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (response.status == ResetStatus::Accepted) {
         // gracefully stop all transactions and send StopTransaction. Restart software afterwards
@@ -2250,7 +2255,7 @@ void ChargePointImpl::handleUnlockConnectorRequest(ocpp::Call<UnlockConnectorReq
     }
 
     ocpp::CallResult<UnlockConnectorResponse> call_result(response, call.uniqueId);
-    this->send<UnlockConnectorResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePointImpl::handleHeartbeatResponse(CallResult<HeartbeatResponse> call_result) {
@@ -2300,7 +2305,7 @@ void ChargePointImpl::handleSetChargingProfileRequest(ocpp::Call<SetChargingProf
     }
 
     ocpp::CallResult<SetChargingProfileResponse> call_result(response, call.uniqueId);
-    this->send<SetChargingProfileResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (response.status == ChargingProfileStatus::Accepted) {
         if (this->signal_set_charging_profiles_callback != nullptr) {
@@ -2348,7 +2353,7 @@ void ChargePointImpl::handleGetCompositeScheduleRequest(ocpp::Call<GetCompositeS
     }
 
     ocpp::CallResult<GetCompositeScheduleResponse> call_result(response, call.uniqueId);
-    this->send<GetCompositeScheduleResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePointImpl::handleClearChargingProfileRequest(ocpp::Call<ClearChargingProfileRequest> call) {
@@ -2374,7 +2379,7 @@ void ChargePointImpl::handleClearChargingProfileRequest(ocpp::Call<ClearCharging
     }
 
     ocpp::CallResult<ClearChargingProfileResponse> call_result(response, call.uniqueId);
-    this->send<ClearChargingProfileResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (response.status == ClearChargingProfileStatus::Accepted and
         this->signal_set_charging_profiles_callback != nullptr) {
@@ -2416,7 +2421,7 @@ void ChargePointImpl::handleTriggerMessageRequest(ocpp::Call<TriggerMessageReque
     }
 
     ocpp::CallResult<TriggerMessageResponse> call_result(response, call.uniqueId);
-    this->send<TriggerMessageResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (!valid) {
         return;
@@ -2476,7 +2481,7 @@ void ChargePointImpl::handleGetDiagnosticsRequest(ocpp::Call<GetDiagnosticsReque
         }
     }
     ocpp::CallResult<GetDiagnosticsResponse> call_result(response, call.uniqueId);
-    this->send<GetDiagnosticsResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePointImpl::handleUpdateFirmwareRequest(ocpp::Call<UpdateFirmwareRequest> call) {
@@ -2486,7 +2491,7 @@ void ChargePointImpl::handleUpdateFirmwareRequest(ocpp::Call<UpdateFirmwareReque
         this->update_firmware_callback(call.msg);
     }
     ocpp::CallResult<UpdateFirmwareResponse> call_result(response, call.uniqueId);
-    this->send<UpdateFirmwareResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePointImpl::handleExtendedTriggerMessageRequest(ocpp::Call<ExtendedTriggerMessageRequest> call) {
@@ -2532,7 +2537,7 @@ void ChargePointImpl::handleExtendedTriggerMessageRequest(ocpp::Call<ExtendedTri
     }
 
     ocpp::CallResult<ExtendedTriggerMessageResponse> call_result(response, call.uniqueId);
-    this->send<ExtendedTriggerMessageResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (!valid) {
         return;
@@ -2614,7 +2619,7 @@ void ChargePointImpl::sign_certificate(const ocpp::CertificateSigningUseEnum& ce
     req.csr = response.csr.value();
 
     ocpp::Call<SignCertificateRequest> call(req, this->message_queue->createMessageId());
-    this->send<SignCertificateRequest>(call, initiated_by_trigger_message);
+    this->message_dispatcher->dispatch_call(call, initiated_by_trigger_message);
 }
 
 void ChargePointImpl::update_ocsp_cache() {
@@ -2659,7 +2664,7 @@ void ChargePointImpl::handleCertificateSignedRequest(ocpp::Call<CertificateSigne
     }
 
     ocpp::CallResult<CertificateSignedResponse> call_result(response, call.uniqueId);
-    this->send<CertificateSignedResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (response.status == CertificateSignedStatusEnumType::Rejected) {
         this->securityEventNotification(
@@ -2704,7 +2709,7 @@ void ChargePointImpl::handleGetInstalledCertificateIdsRequest(ocpp::Call<GetInst
     }
 
     ocpp::CallResult<GetInstalledCertificateIdsResponse> call_result(response, call.uniqueId);
-    this->send<GetInstalledCertificateIdsResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePointImpl::handleDeleteCertificateRequest(ocpp::Call<DeleteCertificateRequest> call) {
@@ -2719,7 +2724,7 @@ void ChargePointImpl::handleDeleteCertificateRequest(ocpp::Call<DeleteCertificat
         ocpp::conversions::delete_certificate_result_to_string(result));
 
     ocpp::CallResult<DeleteCertificateResponse> call_result(response, call.uniqueId);
-    this->send<DeleteCertificateResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePointImpl::handleInstallCertificateRequest(ocpp::Call<InstallCertificateRequest> call) {
@@ -2744,7 +2749,7 @@ void ChargePointImpl::handleInstallCertificateRequest(ocpp::Call<InstallCertific
     }
 
     ocpp::CallResult<InstallCertificateResponse> call_result(response, call.uniqueId);
-    this->send<InstallCertificateResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (response.status == InstallCertificateStatusEnumType::Rejected) {
         this->securityEventNotification(
@@ -2764,7 +2769,7 @@ void ChargePointImpl::handleGetLogRequest(ocpp::Call<GetLogRequest> call) {
     }
 
     ocpp::CallResult<GetLogResponse> call_result(response, call.uniqueId);
-    this->send<GetLogResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePointImpl::handleSignedUpdateFirmware(ocpp::Call<SignedUpdateFirmwareRequest> call) {
@@ -2776,11 +2781,11 @@ void ChargePointImpl::handleSignedUpdateFirmware(ocpp::Call<SignedUpdateFirmware
         ocpp::CertificateValidationResult::Valid) {
         response.status = UpdateFirmwareStatusEnumType::InvalidCertificate;
         ocpp::CallResult<SignedUpdateFirmwareResponse> call_result(response, call.uniqueId);
-        this->send<SignedUpdateFirmwareResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
     } else {
         response.status = this->signed_update_firmware_callback(call.msg);
         ocpp::CallResult<SignedUpdateFirmwareResponse> call_result(response, call.uniqueId);
-        this->send<SignedUpdateFirmwareResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
     }
 
     if (response.status == UpdateFirmwareStatusEnumType::InvalidCertificate) {
@@ -2813,7 +2818,7 @@ void ChargePointImpl::securityEventNotification(const CiString<50>& event_type,
 
     if (critical_security_event and !this->configuration->getDisableSecurityEventNotifications()) {
         ocpp::Call<SecurityEventNotificationRequest> call(req, this->message_queue->createMessageId());
-        this->send<SecurityEventNotificationRequest>(call);
+        this->message_dispatcher->dispatch_call(call);
     }
 
     if (triggered_internally and this->security_event_callback != nullptr) {
@@ -2834,7 +2839,7 @@ void ChargePointImpl::log_status_notification(UploadLogStatusEnumType status, in
     this->log_status_request_id = requestId;
 
     ocpp::Call<LogStatusNotificationRequest> call(req, this->message_queue->createMessageId());
-    this->send<LogStatusNotificationRequest>(call, initiated_by_trigger_message);
+    this->message_dispatcher->dispatch_call(call, initiated_by_trigger_message);
 }
 
 void ChargePointImpl::signed_firmware_update_status_notification(FirmwareStatusEnumType status, int requestId,
@@ -2861,7 +2866,7 @@ void ChargePointImpl::signed_firmware_update_status_notification(FirmwareStatusE
     this->signed_firmware_status_request_id = requestId;
 
     ocpp::Call<SignedFirmwareStatusNotificationRequest> call(req, this->message_queue->createMessageId());
-    this->send<SignedFirmwareStatusNotificationRequest>(call, initiated_by_trigger_message);
+    this->message_dispatcher->dispatch_call(call, initiated_by_trigger_message);
 
     if (status == FirmwareStatusEnumType::InvalidSignature) {
         this->securityEventNotification(ocpp::security_events::INVALIDFIRMWARESIGNATURE, std::nullopt, true);
@@ -2887,7 +2892,7 @@ void ChargePointImpl::handleReserveNowRequest(ocpp::Call<ReserveNowRequest> call
     }
 
     ocpp::CallResult<ReserveNowResponse> call_result(response, call.uniqueId);
-    this->send<ReserveNowResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePointImpl::handleCancelReservationRequest(ocpp::Call<CancelReservationRequest> call) {
@@ -2900,7 +2905,7 @@ void ChargePointImpl::handleCancelReservationRequest(ocpp::Call<CancelReservatio
         }
     }
     ocpp::CallResult<CancelReservationResponse> call_result(response, call.uniqueId);
-    this->send<CancelReservationResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePointImpl::handleSendLocalListRequest(ocpp::Call<SendLocalListRequest> call) {
@@ -2954,7 +2959,7 @@ void ChargePointImpl::handleSendLocalListRequest(ocpp::Call<SendLocalListRequest
     }
 
     ocpp::CallResult<SendLocalListResponse> call_result(response, call.uniqueId);
-    this->send<SendLocalListResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePointImpl::handleGetLocalListVersionRequest(ocpp::Call<GetLocalListVersionRequest> call) {
@@ -2976,7 +2981,7 @@ void ChargePointImpl::handleGetLocalListVersionRequest(ocpp::Call<GetLocalListVe
         } catch (QueryExecutionException& e) {
             auto call_error = CallError(call.uniqueId, "InternalError", "Could not retrieve listVersion from database",
                                         json({}, true));
-            this->send(call_error);
+            this->message_dispatcher->dispatch_call_error(call_error);
             return;
         } catch (RequiredEntryNotFoundException& e) {
             try {
@@ -2987,13 +2992,13 @@ void ChargePointImpl::handleGetLocalListVersionRequest(ocpp::Call<GetLocalListVe
             }
             auto call_error = CallError(call.uniqueId, "InternalError", "Could not retrieve listVersion from database",
                                         json({}, true));
-            this->send(call_error);
+            this->message_dispatcher->dispatch_call_error(call_error);
             return;
         }
     }
 
     ocpp::CallResult<GetLocalListVersionResponse> call_result(response, call.uniqueId);
-    this->send<GetLocalListVersionResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 DataTransferResponse ChargePointImpl::handle_set_user_price(const std::optional<std::string>& msg) {
@@ -3215,58 +3220,6 @@ void ChargePointImpl::set_time_offset_timer(const std::string& date_time) {
     this->change_time_offset_timer->at(d.to_time_point());
 }
 
-template <class T> bool ChargePointImpl::send(ocpp::Call<T> call, bool initiated_by_trigger_message) {
-    const auto message_type = conversions::string_to_messagetype(json(call).at(CALL_ACTION));
-    const auto message_transmission_priority = get_message_transmission_priority(
-        is_boot_notification_message(message_type), initiated_by_trigger_message,
-        (this->registration_status == RegistrationStatus::Accepted), is_transaction_message(message_type),
-        this->configuration->getQueueAllMessages().value_or(false));
-    switch (message_transmission_priority) {
-    case MessageTransmissionPriority::SendImmediately:
-        this->message_queue->push(call);
-        return true;
-    case MessageTransmissionPriority::SendAfterRegistrationStatusAccepted:
-        this->message_queue->push(call, true);
-        return true;
-    case MessageTransmissionPriority::Discard:
-        return false;
-    }
-    throw std::runtime_error("Missing handling for MessageTransmissionPriority");
-}
-
-template <class T>
-std::future<EnhancedMessage<v16::MessageType>> ChargePointImpl::send_async(ocpp::Call<T> call,
-                                                                           bool initiated_by_trigger_message) {
-    const auto message_type = conversions::string_to_messagetype(json(call).at(CALL_ACTION));
-    const auto message_transmission_priority = get_message_transmission_priority(
-        is_boot_notification_message(message_type), initiated_by_trigger_message,
-        (this->registration_status == RegistrationStatus::Accepted), is_transaction_message(message_type),
-        this->configuration->getQueueAllMessages().value_or(false));
-
-    switch (message_transmission_priority) {
-    case MessageTransmissionPriority::SendImmediately:
-        return this->message_queue->push_async(call);
-    case MessageTransmissionPriority::SendAfterRegistrationStatusAccepted:
-    case MessageTransmissionPriority::Discard:
-        auto promise = std::promise<EnhancedMessage<MessageType>>();
-        auto enhanced_message = EnhancedMessage<MessageType>();
-        enhanced_message.offline = true;
-        promise.set_value(enhanced_message);
-        return promise.get_future();
-    }
-    throw std::runtime_error("Missing handling for MessageTransmissionPriority");
-}
-
-template <class T> bool ChargePointImpl::send(ocpp::CallResult<T> call_result) {
-    this->message_queue->push(call_result);
-    return true;
-}
-
-bool ChargePointImpl::send(CallError call_error) {
-    this->message_queue->push(call_error);
-    return true;
-}
-
 void ChargePointImpl::status_notification(const int32_t connector, const ChargePointErrorCode errorCode,
                                           const ChargePointStatus status, const ocpp::DateTime& timestamp,
                                           const std::optional<CiString<50>>& info,
@@ -3282,7 +3235,7 @@ void ChargePointImpl::status_notification(const int32_t connector, const ChargeP
     request.vendorId = vendor_id;
     request.vendorErrorCode = vendor_error_code;
     ocpp::Call<StatusNotificationRequest> call(request, this->message_queue->createMessageId());
-    this->send<StatusNotificationRequest>(call, initiated_by_trigger_message);
+    this->message_dispatcher->dispatch_call(call, initiated_by_trigger_message);
 }
 
 // public API for Core profile
@@ -3329,7 +3282,7 @@ IdTagInfo ChargePointImpl::authorize_id_token(CiString<20> idTag, const bool aut
 
     ocpp::Call<AuthorizeRequest> call(req, this->message_queue->createMessageId());
 
-    auto authorize_future = this->send_async<AuthorizeRequest>(call);
+    auto authorize_future = this->message_dispatcher->dispatch_call_async(call);
 
     if (authorize_future.wait_for(DEFAULT_WAIT_FOR_FUTURE_TIMEOUT) == std::future_status::timeout) {
         EVLOG_warning << "Waiting for Authorize.conf future timed out!";
@@ -3542,7 +3495,7 @@ ocpp::v201::AuthorizeResponse ChargePointImpl::data_transfer_pnc_authorize(
 
         // Send the DataTransfer(Authorize) to the CSMS
         Call<DataTransferRequest> call(req, this->message_queue->createMessageId());
-        auto authorize_future = this->send_async<DataTransferRequest>(call);
+        auto authorize_future = this->message_dispatcher->dispatch_call_async(call);
 
         if (authorize_future.wait_for(DEFAULT_WAIT_FOR_FUTURE_TIMEOUT) == std::future_status::timeout) {
             EVLOG_warning << "Waiting for DataTransfer.conf(Authorize) future timed out!";
@@ -3624,7 +3577,7 @@ void ChargePointImpl::data_transfer_pnc_sign_certificate() {
     req.data.emplace(json(csr_req).dump());
 
     Call<DataTransferRequest> call(req, this->message_queue->createMessageId());
-    this->send<DataTransferRequest>(call);
+    this->message_dispatcher->dispatch_call(call);
 }
 
 void ChargePointImpl::data_transfer_pnc_get_15118_ev_certificate(
@@ -3650,7 +3603,7 @@ void ChargePointImpl::data_transfer_pnc_get_15118_ev_certificate(
     req.data.emplace(json(cert_req).dump());
 
     Call<DataTransferRequest> call(req, this->message_queue->createMessageId());
-    auto future = this->send_async<DataTransferRequest>(call);
+    auto future = this->message_dispatcher->dispatch_call_async(call);
 
     if (future.wait_for(DEFAULT_WAIT_FOR_FUTURE_TIMEOUT) == std::future_status::timeout) {
         EVLOG_warning << "Waiting for DataTransfer.conf(Get15118EVCertificate) future timed out!";
@@ -3700,7 +3653,7 @@ void ChargePointImpl::data_transfer_pnc_get_certificate_status(const ocpp::v201:
     req.data.emplace(json(cert_status_req).dump());
 
     Call<DataTransferRequest> call(req, this->message_queue->createMessageId());
-    auto future = this->send_async<DataTransferRequest>(call);
+    auto future = this->message_dispatcher->dispatch_call_async(call);
 
     if (future.wait_for(DEFAULT_WAIT_FOR_FUTURE_TIMEOUT) == std::future_status::timeout) {
         EVLOG_warning << "Waiting for DataTransfer.conf(GetCertificateStatus) future timed out!";
@@ -3770,7 +3723,7 @@ void ChargePointImpl::handle_data_transfer_pnc_trigger_message(Call<DataTransfer
     }
 
     CallResult<DataTransferResponse> call_result(response, call.uniqueId);
-    this->send<DataTransferResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (response.status == DataTransferStatus::Accepted) {
         // send sign certificate wrapped in data_transfer
@@ -3820,7 +3773,7 @@ void ChargePointImpl::handle_data_transfer_pnc_certificate_signed(Call<DataTrans
         response.data.emplace(json(certificate_response).dump());
 
         CallResult<DataTransferResponse> call_result(response, call.uniqueId);
-        this->send<DataTransferResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
 
         if (certificate_response.status == CertificateSignedStatusEnumType::Rejected) {
             this->securityEventNotification(ocpp::security_events::INVALIDCHARGEPOINTCERTIFICATE,
@@ -3829,11 +3782,11 @@ void ChargePointImpl::handle_data_transfer_pnc_certificate_signed(Call<DataTrans
     } catch (const json::exception& e) {
         EVLOG_warning << "Could not parse data of DataTransfer message CertificateSigned.req: " << e.what();
         CallResult<DataTransferResponse> call_result(response, call.uniqueId);
-        this->send<DataTransferResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
     } catch (const std::exception& e) {
         EVLOG_error << "Unknown Error while handling DataTransfer message CertificateSigned.req: " << e.what();
         CallResult<DataTransferResponse> call_result(response, call.uniqueId);
-        this->send<DataTransferResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
     }
 }
 
@@ -3883,7 +3836,7 @@ void ChargePointImpl::handle_data_transfer_pnc_get_installed_certificates(Call<D
     }
 
     CallResult<DataTransferResponse> call_result(response, call.uniqueId);
-    this->send<DataTransferResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePointImpl::handle_data_transfer_delete_certificate(Call<DataTransferRequest> call) {
@@ -3913,7 +3866,7 @@ void ChargePointImpl::handle_data_transfer_delete_certificate(Call<DataTransferR
     }
 
     CallResult<DataTransferResponse> call_result(response, call.uniqueId);
-    this->send<DataTransferResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePointImpl::handle_data_transfer_install_certificate(Call<DataTransferRequest> call) {
@@ -3941,7 +3894,7 @@ void ChargePointImpl::handle_data_transfer_install_certificate(Call<DataTransfer
     }
 
     CallResult<DataTransferResponse> call_result(response, call.uniqueId);
-    this->send<DataTransferResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 std::optional<DataTransferResponse> ChargePointImpl::data_transfer(const CiString<255>& vendorId,
@@ -3955,7 +3908,7 @@ std::optional<DataTransferResponse> ChargePointImpl::data_transfer(const CiStrin
     DataTransferResponse response;
     response.status = DataTransferStatus::Rejected;
     ocpp::Call<DataTransferRequest> call(req, this->message_queue->createMessageId());
-    auto data_transfer_future = this->send_async<DataTransferRequest>(call);
+    auto data_transfer_future = this->message_dispatcher->dispatch_call_async(call);
 
     if (this->websocket == nullptr or !this->websocket->is_connected()) {
         EVLOG_warning << "Attempting to send DataTransfer.req but charging station is offline";
@@ -4057,7 +4010,7 @@ void ChargePointImpl::start_transaction(std::shared_ptr<Transaction> transaction
     transaction->set_start_transaction_message_id(message_id.get());
     transaction->change_meter_values_sample_interval(this->configuration->getMeterValueSampleInterval());
 
-    this->send<StartTransactionRequest>(call);
+    this->message_dispatcher->dispatch_call(call);
 
     if (this->transaction_started_callback != nullptr) {
         this->transaction_started_callback(transaction->get_connector(), transaction->get_session_id());
@@ -4222,7 +4175,7 @@ void ChargePointImpl::stop_transaction(int32_t connector, Reason reason, std::op
 
     {
         std::lock_guard<std::mutex> lock(this->stop_transaction_mutex);
-        this->send<StopTransactionRequest>(call);
+        this->message_dispatcher->dispatch_call(call);
     }
 
     if (this->transaction_stopped_callback != nullptr) {
@@ -4370,7 +4323,7 @@ void ChargePointImpl::diagnostic_status_notification(DiagnosticsStatus status, b
     this->diagnostics_status = status;
 
     ocpp::Call<DiagnosticsStatusNotificationRequest> call(req, this->message_queue->createMessageId());
-    this->send_async<DiagnosticsStatusNotificationRequest>(call, true);
+    this->message_dispatcher->dispatch_call_async(call, true);
 }
 
 void ChargePointImpl::firmware_status_notification(FirmwareStatus status, bool initiated_by_trigger_message) {
@@ -4392,7 +4345,7 @@ void ChargePointImpl::firmware_status_notification(FirmwareStatus status, bool i
     this->firmware_status = status;
 
     ocpp::Call<FirmwareStatusNotificationRequest> call(req, this->message_queue->createMessageId());
-    this->send_async<FirmwareStatusNotificationRequest>(call, initiated_by_trigger_message);
+    this->message_dispatcher->dispatch_call_async(call, initiated_by_trigger_message);
 
     if (this->firmware_update_is_pending) {
         this->change_all_connectors_to_unavailable_for_firmware_update();
diff --git a/lib/ocpp/v16/message_dispatcher.cpp b/lib/ocpp/v16/message_dispatcher.cpp
new file mode 100644
index 000000000..6283c5e7b
--- /dev/null
+++ b/lib/ocpp/v16/message_dispatcher.cpp
@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+
+#include <ocpp/v16/message_dispatcher.hpp>
+
+namespace ocpp {
+namespace v16 {
+
+void MessageDispatcher::dispatch_call(const json& call, bool triggered) {
+    const auto message_type = conversions::string_to_messagetype(call.at(CALL_ACTION));
+    const auto message_transmission_priority = get_message_transmission_priority(
+        is_boot_notification_message(message_type), triggered,
+        (this->registration_status == RegistrationStatus::Accepted), is_transaction_message(message_type),
+        this->configuration.getQueueAllMessages().value_or(false));
+    switch (message_transmission_priority) {
+    case MessageTransmissionPriority::SendImmediately:
+        this->message_queue.push_call(call);
+        return;
+    case MessageTransmissionPriority::SendAfterRegistrationStatusAccepted:
+        this->message_queue.push_call(call, true);
+        return;
+    case MessageTransmissionPriority::Discard:
+        return;
+    }
+    throw std::runtime_error("Missing handling for MessageTransmissionPriority");
+}
+
+std::future<ocpp::EnhancedMessage<MessageType>> MessageDispatcher::dispatch_call_async(const json& call,
+                                                                                       bool triggered) {
+    const auto message_type = conversions::string_to_messagetype(call.at(CALL_ACTION));
+    const auto message_transmission_priority = get_message_transmission_priority(
+        is_boot_notification_message(message_type), triggered,
+        (this->registration_status == RegistrationStatus::Accepted), is_transaction_message(message_type),
+        this->configuration.getQueueAllMessages().value_or(false));
+
+    switch (message_transmission_priority) {
+    case MessageTransmissionPriority::SendImmediately:
+        return this->message_queue.push_call_async(call);
+    case MessageTransmissionPriority::SendAfterRegistrationStatusAccepted:
+    case MessageTransmissionPriority::Discard:
+        auto promise = std::promise<EnhancedMessage<MessageType>>();
+        auto enhanced_message = EnhancedMessage<MessageType>();
+        enhanced_message.offline = true;
+        promise.set_value(enhanced_message);
+        return promise.get_future();
+    }
+    throw std::runtime_error("Missing handling for MessageTransmissionPriority");
+}
+
+void MessageDispatcher::dispatch_call_result(const json& call_result) {
+    this->message_queue.push_call_result(call_result);
+}
+
+void MessageDispatcher::dispatch_call_error(const json& call_error) {
+    this->message_queue.push_call_error(call_error);
+}
+
+} // namespace v16
+} // namespace ocpp
\ No newline at end of file
diff --git a/lib/ocpp/v201/charge_point.cpp b/lib/ocpp/v201/charge_point.cpp
index 6043d228c..3f9fda8cc 100644
--- a/lib/ocpp/v201/charge_point.cpp
+++ b/lib/ocpp/v201/charge_point.cpp
@@ -1,10 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright Pionix GmbH and Contributors to EVerest
 
+#include <ocpp/common/constants.hpp>
 #include <ocpp/common/types.hpp>
 #include <ocpp/v201/charge_point.hpp>
 #include <ocpp/v201/ctrlr_component_variables.hpp>
 #include <ocpp/v201/device_model_storage_sqlite.hpp>
+#include <ocpp/v201/message_dispatcher.hpp>
 #include <ocpp/v201/messages/FirmwareStatusNotification.hpp>
 #include <ocpp/v201/messages/LogStatusNotification.hpp>
 #include <ocpp/v201/messages/NotifyDisplayMessages.hpp>
@@ -19,7 +21,6 @@ using namespace std::chrono_literals;
 const auto DEFAULT_MAX_CUSTOMER_INFORMATION_DATA_LENGTH = 51200;
 const std::string VARIABLE_ATTRIBUTE_VALUE_SOURCE_INTERNAL = "internal";
 const std::string VARIABLE_ATTRIBUTE_VALUE_SOURCE_CSMS = "csms";
-const auto DEFAULT_WAIT_FOR_FUTURE_TIMEOUT = std::chrono::seconds(60);
 const auto DEFAULT_PRICE_NUMBER_OF_DECIMALS = 3;
 
 using DatabaseException = ocpp::common::DatabaseException;
@@ -74,7 +75,14 @@ ChargePoint::ChargePoint(const std::map<int32_t, int32_t>& evse_connector_struct
         EVLOG_AND_THROW(std::invalid_argument("Database handler should not be null"));
     }
 
+    if (!this->message_queue) {
+        EVLOG_AND_THROW(std::invalid_argument("Message Queue should not be null"));
+    }
+
     initialize(evse_connector_structure, message_log_path);
+
+    this->message_dispatcher =
+        std::make_unique<MessageDispatcher>(*this->message_queue, *this->device_model, registration_status);
 }
 
 ChargePoint::ChargePoint(const std::map<int32_t, int32_t>& evse_connector_structure,
@@ -117,6 +125,9 @@ ChargePoint::ChargePoint(const std::map<int32_t, int32_t>& evse_connector_struct
             message_types_discard_for_queueing,
             this->device_model->get_value<int>(ControllerComponentVariables::MessageTimeout)},
         this->database_handler);
+
+    this->message_dispatcher =
+        std::make_unique<MessageDispatcher>(*this->message_queue, *this->device_model, registration_status);
 }
 
 ChargePoint::ChargePoint(const std::map<int32_t, int32_t>& evse_connector_structure,
@@ -233,7 +244,7 @@ void ChargePoint::on_firmware_update_status_notification(int32_t request_id,
     }
 
     ocpp::Call<FirmwareStatusNotificationRequest> call(req, this->message_queue->createMessageId());
-    this->send_async<FirmwareStatusNotificationRequest>(call);
+    this->message_dispatcher->dispatch_call_async(call);
 
     if (req.status == FirmwareStatusEnum::Installed) {
         std::string firmwareVersionMessage = "New firmware succesfully installed! Version: ";
@@ -262,7 +273,7 @@ void ChargePoint::on_firmware_update_status_notification(int32_t request_id,
             this->firmware_status = FirmwareStatusEnum::InstallScheduled;
             req.status = firmware_status;
             ocpp::Call<FirmwareStatusNotificationRequest> call(req, this->message_queue->createMessageId());
-            this->send_async<FirmwareStatusNotificationRequest>(call);
+            this->message_dispatcher->dispatch_call_async(call);
         }
         this->change_all_connectors_to_unavailable_for_firmware_update();
     }
@@ -287,7 +298,7 @@ ChargePoint::on_get_15118_ev_certificate_request(const Get15118EVCertificateRequ
     }
 
     EVLOG_debug << "Received Get15118EVCertificateRequest " << request;
-    auto future_res = this->send_async<Get15118EVCertificateRequest>(
+    auto future_res = this->message_dispatcher->dispatch_call_async(
         ocpp::Call<Get15118EVCertificateRequest>(request, this->message_queue->createMessageId()));
 
     if (future_res.wait_for(DEFAULT_WAIT_FOR_FUTURE_TIMEOUT) == std::future_status::timeout) {
@@ -309,7 +320,7 @@ ChargePoint::on_get_15118_ev_certificate_request(const Get15118EVCertificateRequ
     } catch (const EnumConversionException& e) {
         EVLOG_error << "EnumConversionException during handling of message: " << e.what();
         auto call_error = CallError(response_message.uniqueId, "FormationViolation", e.what(), json({}));
-        this->send(call_error);
+        this->message_dispatcher->dispatch_call_error(call_error);
         return response;
     }
 }
@@ -1069,7 +1080,7 @@ void ChargePoint::on_log_status_notification(UploadLogStatusEnum status, int32_t
     this->upload_log_status_id = requestId;
 
     ocpp::Call<LogStatusNotificationRequest> call(request, this->message_queue->createMessageId());
-    this->send<LogStatusNotificationRequest>(call);
+    this->message_dispatcher->dispatch_call(call);
 }
 
 void ChargePoint::on_security_event(const CiString<50>& event_type, const std::optional<CiString<255>>& tech_info,
@@ -1087,11 +1098,6 @@ void ChargePoint::on_variable_changed(const SetVariableData& set_variable_data)
     this->handle_variable_changed(set_variable_data);
 }
 
-bool ChargePoint::send(CallError call_error) {
-    this->message_queue->push(call_error);
-    return true;
-}
-
 void ChargePoint::initialize(const std::map<int32_t, int32_t>& evse_connector_structure,
                              const std::string& message_log_path) {
     this->device_model->check_integrity(evse_connector_structure);
@@ -1377,7 +1383,7 @@ void ChargePoint::handle_message(const EnhancedMessage<v201::MessageType>& messa
     default:
         if (message.messageTypeId == MessageTypeId::CALL) {
             const auto call_error = CallError(message.uniqueId, "NotImplemented", "", json({}));
-            this->send(call_error);
+            this->message_dispatcher->dispatch_call_error(call_error);
         }
         break;
     }
@@ -1390,7 +1396,8 @@ void ChargePoint::message_callback(const std::string& message) {
     } catch (const json::exception& e) {
         this->logging->central_system("Unknown", message);
         EVLOG_error << "JSON exception during reception of message: " << e.what();
-        this->send(CallError(MessageId("-1"), "RpcFrameworkError", e.what(), json({})));
+        this->message_dispatcher->dispatch_call_error(
+            CallError(MessageId("-1"), "RpcFrameworkError", e.what(), json({})));
         const auto& security_event = ocpp::security_events::INVALIDMESSAGES;
         this->security_event_notification_req(CiString<50>(security_event), CiString<255>(message), true,
                                               utils::is_critical(security_event));
@@ -1398,7 +1405,7 @@ void ChargePoint::message_callback(const std::string& message) {
     } catch (const EnumConversionException& e) {
         EVLOG_error << "EnumConversionException during handling of message: " << e.what();
         auto call_error = CallError(MessageId("-1"), "FormationViolation", e.what(), json({}));
-        this->send(call_error);
+        this->message_dispatcher->dispatch_call_error(call_error);
         const auto& security_event = ocpp::security_events::INVALIDMESSAGES;
         this->security_event_notification_req(CiString<50>(security_event), CiString<255>(message), true,
                                               utils::is_critical(security_event));
@@ -1429,14 +1436,14 @@ void ChargePoint::message_callback(const std::string& message) {
                     response.status = RequestStartStopStatusEnum::Rejected;
                     const ocpp::CallResult<RequestStartTransactionResponse> call_result(response,
                                                                                         enhanced_message.uniqueId);
-                    this->send<RequestStartTransactionResponse>(call_result);
+                    this->message_dispatcher->dispatch_call_result(call_result);
                 } else if (enhanced_message.messageType == MessageType::RequestStopTransaction) {
                     // Send rejected: B02.FR.05
                     RequestStopTransactionResponse response;
                     response.status = RequestStartStopStatusEnum::Rejected;
                     const ocpp::CallResult<RequestStopTransactionResponse> call_result(response,
                                                                                        enhanced_message.uniqueId);
-                    this->send<RequestStopTransactionResponse>(call_result);
+                    this->message_dispatcher->dispatch_call_result(call_result);
                 } else {
                     std::string const call_error_message =
                         "Received invalid MessageType: " +
@@ -1446,7 +1453,7 @@ void ChargePoint::message_callback(const std::string& message) {
                     // B02.FR.09 send CALLERROR SecurityError
                     const auto call_error =
                         CallError(enhanced_message.uniqueId, "SecurityError", call_error_message, json({}));
-                    this->send(call_error);
+                    this->message_dispatcher->dispatch_call_error(call_error);
                 }
             }
         } else if (this->registration_status == RegistrationStatusEnum::Rejected) {
@@ -1462,37 +1469,37 @@ void ChargePoint::message_callback(const std::string& message) {
                         "having received an accepted BootNotificationResponse";
                     EVLOG_warning << error_message;
                     const auto call_error = CallError(enhanced_message.uniqueId, "SecurityError", "", json({}));
-                    this->send(call_error);
+                    this->message_dispatcher->dispatch_call_error(call_error);
                 }
             } else {
                 const auto error_message = "Received other message than BootNotificationResponse before "
                                            "having received an accepted BootNotificationResponse";
                 EVLOG_warning << error_message;
                 const auto call_error = CallError(enhanced_message.uniqueId, "SecurityError", "", json({}, true));
-                this->send(call_error);
+                this->message_dispatcher->dispatch_call_error(call_error);
             }
         }
     } catch (const EvseOutOfRangeException& e) {
         EVLOG_error << "Exception during handling of message: " << e.what();
         auto call_error = CallError(enhanced_message.uniqueId, "OccurrenceConstraintViolation", e.what(), json({}));
-        this->send(call_error);
+        this->message_dispatcher->dispatch_call_error(call_error);
     } catch (const ConnectorOutOfRangeException& e) {
         EVLOG_error << "Exception during handling of message: " << e.what();
         auto call_error = CallError(enhanced_message.uniqueId, "OccurrenceConstraintViolation", e.what(), json({}));
-        this->send(call_error);
+        this->message_dispatcher->dispatch_call_error(call_error);
     } catch (const EnumConversionException& e) {
         EVLOG_error << "EnumConversionException during handling of message: " << e.what();
         auto call_error = CallError(enhanced_message.uniqueId, "FormationViolation", e.what(), json({}));
-        this->send(call_error);
+        this->message_dispatcher->dispatch_call_error(call_error);
     } catch (const TimePointParseException& e) {
         EVLOG_error << "Exception during handling of message: " << e.what();
         auto call_error = CallError(enhanced_message.uniqueId, "FormationViolation", e.what(), json({}));
-        this->send(call_error);
+        this->message_dispatcher->dispatch_call_error(call_error);
     } catch (json::exception& e) {
         EVLOG_error << "JSON exception during handling of message: " << e.what();
         if (json_message.is_array() and json_message.size() > MESSAGE_ID) {
             auto call_error = CallError(enhanced_message.uniqueId, "FormationViolation", e.what(), json({}));
-            this->send(call_error);
+            this->message_dispatcher->dispatch_call_error(call_error);
         }
     }
 }
@@ -2014,7 +2021,7 @@ void ChargePoint::security_event_notification_req(const CiString<50>& event_type
     this->logging->security(json(req).dump());
     if (critical) {
         ocpp::Call<SecurityEventNotificationRequest> call(req, this->message_queue->createMessageId());
-        this->send<SecurityEventNotificationRequest>(call);
+        this->message_dispatcher->dispatch_call(call);
     }
     if (triggered_internally and this->callbacks.security_event_callback != nullptr) {
         this->callbacks.security_event_callback(event_type, tech_info);
@@ -2089,7 +2096,7 @@ void ChargePoint::sign_certificate_req(const ocpp::CertificateSigningUseEnum& ce
     this->awaited_certificate_signing_use_enum = certificate_signing_use;
 
     ocpp::Call<SignCertificateRequest> call(req, this->message_queue->createMessageId());
-    this->send<SignCertificateRequest>(call, initiated_by_trigger_message);
+    this->message_dispatcher->dispatch_call(call, initiated_by_trigger_message);
 }
 
 void ChargePoint::boot_notification_req(const BootReasonEnum& reason, const bool initiated_by_trigger_message) {
@@ -2109,7 +2116,7 @@ void ChargePoint::boot_notification_req(const BootReasonEnum& reason, const bool
     req.chargingStation = charging_station;
 
     ocpp::Call<BootNotificationRequest> call(req, this->message_queue->createMessageId());
-    this->send<BootNotificationRequest>(call, initiated_by_trigger_message);
+    this->message_dispatcher->dispatch_call(call, initiated_by_trigger_message);
 }
 
 void ChargePoint::notify_report_req(const int request_id, const std::vector<ReportData>& report_data) {
@@ -2123,7 +2130,7 @@ void ChargePoint::notify_report_req(const int request_id, const std::vector<Repo
 
     if (report_data.size() <= 1) {
         ocpp::Call<NotifyReportRequest> call(req, this->message_queue->createMessageId());
-        this->send<NotifyReportRequest>(call);
+        this->message_dispatcher->dispatch_call(call);
     } else {
         NotifyReportRequestsSplitter splitter{
             req,
@@ -2131,7 +2138,7 @@ void ChargePoint::notify_report_req(const int request_id, const std::vector<Repo
                 .value_or(DEFAULT_MAX_MESSAGE_SIZE),
             [this]() { return this->message_queue->createMessageId(); }};
         for (const auto& msg : splitter.create_call_payloads()) {
-            this->message_queue->push(msg);
+            this->message_queue->push_call(msg);
         }
     }
 }
@@ -2151,7 +2158,7 @@ AuthorizeResponse ChargePoint::authorize_req(const IdToken id_token, const std::
     }
 
     ocpp::Call<AuthorizeRequest> call(req, this->message_queue->createMessageId());
-    auto future = this->send_async<AuthorizeRequest>(call);
+    auto future = this->message_dispatcher->dispatch_call_async(call);
 
     if (future.wait_for(DEFAULT_WAIT_FOR_FUTURE_TIMEOUT) == std::future_status::timeout) {
         EVLOG_warning << "Waiting for DataTransfer.conf(Authorize) future timed out!";
@@ -2170,7 +2177,7 @@ AuthorizeResponse ChargePoint::authorize_req(const IdToken id_token, const std::
     } catch (const EnumConversionException& e) {
         EVLOG_error << "EnumConversionException during handling of message: " << e.what();
         auto call_error = CallError(enhanced_message.uniqueId, "FormationViolation", e.what(), json({}));
-        this->send(call_error);
+        this->message_dispatcher->dispatch_call_error(call_error);
         return response;
     }
 }
@@ -2184,7 +2191,7 @@ void ChargePoint::status_notification_req(const int32_t evse_id, const int32_t c
     req.connectorStatus = status;
 
     ocpp::Call<StatusNotificationRequest> call(req, this->message_queue->createMessageId());
-    this->send<StatusNotificationRequest>(call, initiated_by_trigger_message);
+    this->message_dispatcher->dispatch_call(call, initiated_by_trigger_message);
 }
 
 void ChargePoint::heartbeat_req(const bool initiated_by_trigger_message) {
@@ -2192,7 +2199,7 @@ void ChargePoint::heartbeat_req(const bool initiated_by_trigger_message) {
 
     heartbeat_request_time = std::chrono::steady_clock::now();
     ocpp::Call<HeartbeatRequest> call(req, this->message_queue->createMessageId());
-    this->send<HeartbeatRequest>(call, initiated_by_trigger_message);
+    this->message_dispatcher->dispatch_call(call, initiated_by_trigger_message);
 }
 
 void ChargePoint::transaction_event_req(const TransactionEventEnum& event_type, const DateTime& timestamp,
@@ -2248,7 +2255,7 @@ void ChargePoint::transaction_event_req(const TransactionEventEnum& event_type,
         remote_start_id_per_evse.erase(it);
     }
 
-    this->send<TransactionEventRequest>(call, initiated_by_trigger_message);
+    this->message_dispatcher->dispatch_call(call, initiated_by_trigger_message);
 
     if (this->callbacks.transaction_event_callback.has_value()) {
         this->callbacks.transaction_event_callback.value()(req);
@@ -2262,7 +2269,7 @@ void ChargePoint::meter_values_req(const int32_t evse_id, const std::vector<Mete
     req.meterValue = meter_values;
 
     ocpp::Call<MeterValuesRequest> call(req, this->message_queue->createMessageId());
-    this->send<MeterValuesRequest>(call, initiated_by_trigger_message);
+    this->message_dispatcher->dispatch_call(call, initiated_by_trigger_message);
 }
 
 void ChargePoint::report_charging_profile_req(const int32_t request_id, const int32_t evse_id,
@@ -2276,12 +2283,12 @@ void ChargePoint::report_charging_profile_req(const int32_t request_id, const in
     req.tbc = tbc;
 
     ocpp::Call<ReportChargingProfilesRequest> call(req, this->message_queue->createMessageId());
-    this->send<ReportChargingProfilesRequest>(call);
+    this->message_dispatcher->dispatch_call(call);
 }
 
 void ChargePoint::report_charging_profile_req(const ReportChargingProfilesRequest& req) {
     ocpp::Call<ReportChargingProfilesRequest> call(req, this->message_queue->createMessageId());
-    this->send<ReportChargingProfilesRequest>(call);
+    this->message_dispatcher->dispatch_call(call);
 }
 
 void ChargePoint::notify_event_req(const std::vector<EventData>& events) {
@@ -2291,7 +2298,7 @@ void ChargePoint::notify_event_req(const std::vector<EventData>& events) {
     req.seqNo = 0;
 
     ocpp::Call<NotifyEventRequest> call(req, this->message_queue->createMessageId());
-    this->send<NotifyEventRequest>(call);
+    this->message_dispatcher->dispatch_call(call);
 }
 
 void ChargePoint::notify_customer_information_req(const std::string& data, const int32_t request_id) {
@@ -2309,7 +2316,7 @@ void ChargePoint::notify_customer_information_req(const std::string& data, const
         }();
 
         ocpp::Call<NotifyCustomerInformationRequest> call(req, this->message_queue->createMessageId());
-        this->send<NotifyCustomerInformationRequest>(call);
+        this->message_dispatcher->dispatch_call(call);
 
         pos += 512;
         seq_no++;
@@ -2353,7 +2360,7 @@ void ChargePoint::handle_certificate_signed_req(Call<CertificateSignedRequest> c
     }
 
     ocpp::CallResult<CertificateSignedResponse> call_result(response, call.uniqueId);
-    this->send<CertificateSignedResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (result != ocpp::InstallCertificateResult::Accepted) {
         this->security_event_notification_req("InvalidChargingStationCertificate",
@@ -2492,7 +2499,7 @@ void ChargePoint::handle_set_variables_req(Call<SetVariablesRequest> call) {
     }
 
     ocpp::CallResult<SetVariablesResponse> call_result(response, call.uniqueId);
-    this->send<SetVariablesResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     // post handling of changed variables after the SetVariables.conf has been queued
     this->handle_variables_changed(set_variables_response);
@@ -2511,7 +2518,7 @@ void ChargePoint::handle_get_variables_req(const EnhancedMessage<v201::MessageTy
     if (msg.getVariableData.size() > max_variables_per_message) {
         // send a CALLERROR
         const auto call_error = CallError(call.uniqueId, "OccurenceConstraintViolation", "", json({}));
-        this->send(call_error);
+        this->message_dispatcher->dispatch_call_error(call_error);
         return;
     }
 
@@ -2519,7 +2526,7 @@ void ChargePoint::handle_get_variables_req(const EnhancedMessage<v201::MessageTy
     if (message.message_size > max_bytes_per_message) {
         // send a CALLERROR
         const auto call_error = CallError(call.uniqueId, "FormatViolation", "", json({}));
-        this->send(call_error);
+        this->message_dispatcher->dispatch_call_error(call_error);
         return;
     }
 
@@ -2527,7 +2534,7 @@ void ChargePoint::handle_get_variables_req(const EnhancedMessage<v201::MessageTy
     response.getVariableResult = this->get_variables(msg.getVariableData);
 
     ocpp::CallResult<GetVariablesResponse> call_result(response, call.uniqueId);
-    this->send<GetVariablesResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_get_base_report_req(Call<GetBaseReportRequest> call) {
@@ -2536,7 +2543,7 @@ void ChargePoint::handle_get_base_report_req(Call<GetBaseReportRequest> call) {
     response.status = GenericDeviceModelStatusEnum::Accepted;
 
     ocpp::CallResult<GetBaseReportResponse> call_result(response, call.uniqueId);
-    this->send<GetBaseReportResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (response.status == GenericDeviceModelStatusEnum::Accepted) {
         const auto report_data = this->device_model->get_base_report_data(msg.reportBase);
@@ -2559,7 +2566,7 @@ void ChargePoint::handle_get_report_req(const EnhancedMessage<v201::MessageType>
     if (msg.componentVariable.has_value() and msg.componentVariable->size() > max_items_per_message) {
         // send a CALLERROR
         const auto call_error = CallError(call.uniqueId, "OccurenceConstraintViolation", "", json({}));
-        this->send(call_error);
+        this->message_dispatcher->dispatch_call_error(call_error);
         return;
     }
 
@@ -2567,7 +2574,7 @@ void ChargePoint::handle_get_report_req(const EnhancedMessage<v201::MessageType>
     if (message.message_size > max_bytes_per_message) {
         // send a CALLERROR
         const auto call_error = CallError(call.uniqueId, "FormatViolation", "", json({}));
-        this->send(call_error);
+        this->message_dispatcher->dispatch_call_error(call_error);
         return;
     }
 
@@ -2599,7 +2606,7 @@ void ChargePoint::handle_get_report_req(const EnhancedMessage<v201::MessageType>
     }
 
     ocpp::CallResult<GetReportResponse> call_result(response, call.uniqueId);
-    this->send<GetReportResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (response.status == GenericDeviceModelStatusEnum::Accepted) {
         this->notify_report_req(msg.requestId, report_data);
@@ -2615,7 +2622,7 @@ void ChargePoint::handle_set_network_profile_req(Call<SetNetworkProfileRequest>
         EVLOG_warning << "No callback registered to validate network profile";
         response.status = SetNetworkProfileStatusEnum::Rejected;
         ocpp::CallResult<SetNetworkProfileResponse> call_result(response, call.uniqueId);
-        this->send<SetNetworkProfileResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
         return;
     }
 
@@ -2624,7 +2631,7 @@ void ChargePoint::handle_set_network_profile_req(Call<SetNetworkProfileRequest>
         EVLOG_warning << "CSMS attempted to set a network profile with a lower securityProfile";
         response.status = SetNetworkProfileStatusEnum::Rejected;
         ocpp::CallResult<SetNetworkProfileResponse> call_result(response, call.uniqueId);
-        this->send<SetNetworkProfileResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
         return;
     }
 
@@ -2633,7 +2640,7 @@ void ChargePoint::handle_set_network_profile_req(Call<SetNetworkProfileRequest>
         EVLOG_warning << "CSMS attempted to set a network profile that could not be validated.";
         response.status = SetNetworkProfileStatusEnum::Rejected;
         ocpp::CallResult<SetNetworkProfileResponse> call_result(response, call.uniqueId);
-        this->send<SetNetworkProfileResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
         return;
     }
 
@@ -2664,7 +2671,7 @@ void ChargePoint::handle_set_network_profile_req(Call<SetNetworkProfileRequest>
         EVLOG_warning << "CSMS attempted to set a network profile that could not be written to the device model";
         response.status = SetNetworkProfileStatusEnum::Rejected;
         ocpp::CallResult<SetNetworkProfileResponse> call_result(response, call.uniqueId);
-        this->send<SetNetworkProfileResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
         return;
     }
 
@@ -2678,7 +2685,7 @@ void ChargePoint::handle_set_network_profile_req(Call<SetNetworkProfileRequest>
 
     response.status = SetNetworkProfileStatusEnum::Accepted;
     ocpp::CallResult<SetNetworkProfileResponse> call_result(response, call.uniqueId);
-    this->send<SetNetworkProfileResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_reset_req(Call<ResetRequest> call) {
@@ -2747,7 +2754,7 @@ void ChargePoint::handle_reset_req(Call<ResetRequest> call) {
     }
 
     ocpp::CallResult<ResetResponse> call_result(response, call.uniqueId);
-    this->send<ResetResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     // Reset response is sent, now set evse connectors to unavailable and / or
     // stop transaction (depending on reset type)
@@ -2783,13 +2790,13 @@ void ChargePoint::handle_clear_cache_req(Call<ClearCacheRequest> call) {
         } catch (DatabaseException& e) {
             auto call_error = CallError(call.uniqueId, "InternalError",
                                         "Database error while clearing authorization cache", json({}, true));
-            this->send(call_error);
+            this->message_dispatcher->dispatch_call_error(call_error);
             return;
         }
     }
 
     ocpp::CallResult<ClearCacheResponse> call_result(response, call.uniqueId);
-    this->send<ClearCacheResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_transaction_event_response(const EnhancedMessage<v201::MessageType>& message) {
@@ -2884,7 +2891,7 @@ void ChargePoint::handle_get_transaction_status(const Call<GetTransactionStatusR
     }
 
     ocpp::CallResult<GetTransactionStatusResponse> call_result(response, call.uniqueId);
-    this->send<GetTransactionStatusResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_unlock_connector(Call<UnlockConnectorRequest> call) {
@@ -2904,7 +2911,7 @@ void ChargePoint::handle_unlock_connector(Call<UnlockConnectorRequest> call) {
     }
 
     ocpp::CallResult<UnlockConnectorResponse> call_result(unlock_response, call.uniqueId);
-    this->send<UnlockConnectorResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_trigger_message(Call<TriggerMessageRequest> call) {
@@ -3006,7 +3013,7 @@ void ChargePoint::handle_trigger_message(Call<TriggerMessageRequest> call) {
     }
 
     ocpp::CallResult<TriggerMessageResponse> call_result(response, call.uniqueId);
-    this->send<TriggerMessageResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (response.status != TriggerMessageStatusEnum::Accepted) {
         return;
@@ -3084,7 +3091,7 @@ void ChargePoint::handle_trigger_message(Call<TriggerMessageRequest> call) {
         }
 
         ocpp::Call<LogStatusNotificationRequest> call(request, this->message_queue->createMessageId());
-        this->send<LogStatusNotificationRequest>(call, true);
+        this->message_dispatcher->dispatch_call(call, true);
     } break;
 
     case MessageTriggerEnum::FirmwareStatusNotification: {
@@ -3103,7 +3110,7 @@ void ChargePoint::handle_trigger_message(Call<TriggerMessageRequest> call) {
         }
 
         ocpp::Call<FirmwareStatusNotificationRequest> call(request, this->message_queue->createMessageId());
-        this->send<FirmwareStatusNotificationRequest>(call, true);
+        this->message_dispatcher->dispatch_call(call, true);
     } break;
 
     case MessageTriggerEnum::SignChargingStationCertificate: {
@@ -3196,7 +3203,7 @@ void ChargePoint::handle_remote_start_transaction_request(Call<RequestStartTrans
     }
 
     const ocpp::CallResult<RequestStartTransactionResponse> call_result(response, call.uniqueId);
-    this->send<RequestStartTransactionResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_remote_stop_transaction_request(Call<RequestStopTransactionRequest> call) {
@@ -3218,7 +3225,7 @@ void ChargePoint::handle_remote_stop_transaction_request(Call<RequestStopTransac
     }
 
     const ocpp::CallResult<RequestStopTransactionResponse> call_result(response, call.uniqueId);
-    this->send<RequestStopTransactionResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_change_availability_req(Call<ChangeAvailabilityRequest> call) {
@@ -3231,7 +3238,7 @@ void ChargePoint::handle_change_availability_req(Call<ChangeAvailabilityRequest>
         EVLOG_warning << "CSMS requested ChangeAvailability for invalid evse id or connector id";
         response.status = ChangeAvailabilityStatusEnum::Rejected;
         ocpp::CallResult<ChangeAvailabilityResponse> call_result(response, call.uniqueId);
-        this->send<ChangeAvailabilityResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
         return;
     }
 
@@ -3263,7 +3270,7 @@ void ChargePoint::handle_change_availability_req(Call<ChangeAvailabilityRequest>
     // Respond to the CSMS before performing any changes to avoid StatusNotification.req being sent before
     // the ChangeAvailabilityResponse.
     ocpp::CallResult<ChangeAvailabilityResponse> call_result(response, call.uniqueId);
-    this->send<ChangeAvailabilityResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (!transaction_active) {
         // No transactions - execute the change now
@@ -3311,7 +3318,7 @@ void ChargePoint::handle_costupdated_req(const Call<CostUpdatedRequest> call) {
     ocpp::CallResult<CostUpdatedResponse> call_result(response, call.uniqueId);
 
     if (!is_cost_enabled() or !this->callbacks.set_running_cost_callback.has_value()) {
-        this->send<CostUpdatedResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
         return;
     }
 
@@ -3355,7 +3362,7 @@ void ChargePoint::handle_costupdated_req(const Call<CostUpdatedRequest> call) {
         this->device_model->get_value<std::string>(ControllerComponentVariables::TariffCostCtrlrCurrency);
     this->callbacks.set_running_cost_callback.value()(running_cost, decimals, currency);
 
-    this->send<CostUpdatedResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     // In OCPP 2.0.1, the chargepoint status trigger is not used.
     if (!triggers.at_energy_kwh.has_value() and !triggers.at_power_kw.has_value() and !triggers.at_time.has_value()) {
@@ -3395,7 +3402,7 @@ void ChargePoint::handle_set_charging_profile_req(Call<SetChargingProfileRequest
 
         const auto call_error =
             CallError(call.uniqueId, "NotSupported", "Charging Station does not support smart charging", json({}));
-        this->send(call_error);
+        this->message_dispatcher->dispatch_call_error(call_error);
 
         return;
     }
@@ -3409,7 +3416,7 @@ void ChargePoint::handle_set_charging_profile_req(Call<SetChargingProfileRequest
                     << "\nadditionalInfo: " << response.statusInfo->additionalInfo->get();
 
         ocpp::CallResult<SetChargingProfileResponse> call_result(response, call.uniqueId);
-        this->send<SetChargingProfileResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
 
         return;
     }
@@ -3424,7 +3431,7 @@ void ChargePoint::handle_set_charging_profile_req(Call<SetChargingProfileRequest
     }
 
     ocpp::CallResult<SetChargingProfileResponse> call_result(response, call.uniqueId);
-    this->send<SetChargingProfileResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_clear_charging_profile_req(Call<ClearChargingProfileRequest> call) {
@@ -3448,7 +3455,7 @@ void ChargePoint::handle_clear_charging_profile_req(Call<ClearChargingProfileReq
     }
 
     ocpp::CallResult<ClearChargingProfileResponse> call_result(response, call.uniqueId);
-    this->send<ClearChargingProfileResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_get_charging_profiles_req(Call<GetChargingProfilesRequest> call) {
@@ -3462,7 +3469,7 @@ void ChargePoint::handle_get_charging_profiles_req(Call<GetChargingProfilesReque
         profiles_to_report.empty() ? GetChargingProfileStatusEnum::NoProfiles : GetChargingProfileStatusEnum::Accepted;
 
     ocpp::CallResult<GetChargingProfilesResponse> call_result(response, call.uniqueId);
-    this->send<GetChargingProfilesResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (response.status == GetChargingProfileStatusEnum::NoProfiles) {
         return;
@@ -3517,7 +3524,7 @@ void ChargePoint::handle_get_composite_schedule_req(Call<GetCompositeScheduleReq
     const auto response = this->get_composite_schedule_internal(call.msg);
 
     ocpp::CallResult<GetCompositeScheduleResponse> call_result(response, call.uniqueId);
-    this->send<GetCompositeScheduleResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_firmware_update_req(Call<UpdateFirmwareRequest> call) {
@@ -3547,7 +3554,7 @@ void ChargePoint::handle_firmware_update_req(Call<UpdateFirmwareRequest> call) {
     }
 
     ocpp::CallResult<UpdateFirmwareResponse> call_result(response, call.uniqueId);
-    this->send<UpdateFirmwareResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if ((response.status == UpdateFirmwareStatusEnum::InvalidCertificate) or
         (response.status == UpdateFirmwareStatusEnum::RevokedCertificate)) {
@@ -3595,7 +3602,7 @@ void ChargePoint::handle_get_installed_certificate_ids_req(Call<GetInstalledCert
     }
 
     ocpp::CallResult<GetInstalledCertificateIdsResponse> call_result(response, call.uniqueId);
-    this->send<GetInstalledCertificateIdsResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_install_certificate_req(Call<InstallCertificateRequest> call) {
@@ -3617,7 +3624,7 @@ void ChargePoint::handle_install_certificate_req(Call<InstallCertificateRequest>
     }
 
     ocpp::CallResult<InstallCertificateResponse> call_result(response, call.uniqueId);
-    this->send<InstallCertificateResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_delete_certificate_req(Call<DeleteCertificateRequest> call) {
@@ -3640,14 +3647,14 @@ void ChargePoint::handle_delete_certificate_req(Call<DeleteCertificateRequest> c
     }
 
     ocpp::CallResult<DeleteCertificateResponse> call_result(response, call.uniqueId);
-    this->send<DeleteCertificateResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_get_log_req(Call<GetLogRequest> call) {
     const GetLogResponse response = this->callbacks.get_log_request_callback(call.msg);
 
     ocpp::CallResult<GetLogResponse> call_result(response, call.uniqueId);
-    this->send<GetLogResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_customer_information_req(Call<CustomerInformationRequest> call) {
@@ -3667,7 +3674,7 @@ void ChargePoint::handle_customer_information_req(Call<CustomerInformationReques
     }
 
     ocpp::CallResult<CustomerInformationResponse> call_result(response, call.uniqueId);
-    this->send<CustomerInformationResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (response.status == CustomerInformationStatusEnum::Accepted) {
         std::string data = "";
@@ -3719,7 +3726,7 @@ void ChargePoint::handle_set_monitoring_base_req(Call<SetMonitoringBaseRequest>
     }
 
     ocpp::CallResult<SetMonitoringBaseResponse> call_result(response, call.uniqueId);
-    this->send<SetMonitoringBaseResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_set_monitoring_level_req(Call<SetMonitoringLevelRequest> call) {
@@ -3743,7 +3750,7 @@ void ChargePoint::handle_set_monitoring_level_req(Call<SetMonitoringLevelRequest
     }
 
     ocpp::CallResult<SetMonitoringLevelResponse> call_result(response, call.uniqueId);
-    this->send<SetMonitoringLevelResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_set_variable_monitoring_req(const EnhancedMessage<v201::MessageType>& message) {
@@ -3759,13 +3766,13 @@ void ChargePoint::handle_set_variable_monitoring_req(const EnhancedMessage<v201:
     // N04.FR.09
     if (msg.setMonitoringData.size() > max_items_per_message) {
         const auto call_error = CallError(call.uniqueId, "OccurenceConstraintViolation", "", json({}));
-        this->send(call_error);
+        this->message_dispatcher->dispatch_call_error(call_error);
         return;
     }
 
     if (message.message_size > max_bytes_message) {
         const auto call_error = CallError(call.uniqueId, "FormatViolation", "", json({}));
-        this->send(call_error);
+        this->message_dispatcher->dispatch_call_error(call_error);
         return;
     }
 
@@ -3776,7 +3783,7 @@ void ChargePoint::handle_set_variable_monitoring_req(const EnhancedMessage<v201:
     }
 
     ocpp::CallResult<SetVariableMonitoringResponse> call_result(response, call.uniqueId);
-    this->send<SetVariableMonitoringResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::notify_monitoring_report_req(const int request_id,
@@ -3792,7 +3799,7 @@ void ChargePoint::notify_monitoring_report_req(const int request_id,
         req.tbc = false;
 
         ocpp::Call<NotifyMonitoringReportRequest> call(req, this->message_queue->createMessageId());
-        this->send<NotifyMonitoringReportRequest>(call);
+        this->message_dispatcher->dispatch_call(call);
     } else {
         // Split for larger message sizes
         int32_t sequence_num = 0;
@@ -3818,7 +3825,7 @@ void ChargePoint::notify_monitoring_report_req(const int request_id,
             req.monitor = sub_data;
 
             ocpp::Call<NotifyMonitoringReportRequest> call(req, this->message_queue->createMessageId());
-            this->send<NotifyMonitoringReportRequest>(call);
+            this->message_dispatcher->dispatch_call(call);
 
             sequence_num++;
         }
@@ -3836,7 +3843,7 @@ void ChargePoint::handle_get_monitoring_report_req(Call<GetMonitoringReportReque
     // N02.FR.07
     if (component_variables.size() > max_variable_components_per_message) {
         const auto call_error = CallError(call.uniqueId, "OccurenceConstraintViolation", "", json({}));
-        this->send(call_error);
+        this->message_dispatcher->dispatch_call_error(call_error);
         return;
     }
 
@@ -3857,7 +3864,7 @@ void ChargePoint::handle_get_monitoring_report_req(Call<GetMonitoringReportReque
     }
 
     ocpp::CallResult<GetMonitoringReportResponse> call_result(response, call.uniqueId);
-    this->send<GetMonitoringReportResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 
     if (response.status == GenericDeviceModelStatusEnum::Accepted) {
         // Send the result with splits if required
@@ -3876,7 +3883,7 @@ void ChargePoint::handle_clear_variable_monitoring_req(Call<ClearVariableMonitor
     }
 
     ocpp::CallResult<ClearVariableMonitoringResponse> call_result(response, call.uniqueId);
-    this->send<ClearVariableMonitoringResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_get_display_message(const Call<GetDisplayMessagesRequest> call) {
@@ -3884,7 +3891,7 @@ void ChargePoint::handle_get_display_message(const Call<GetDisplayMessagesReques
     if (!this->callbacks.get_display_message_callback.has_value()) {
         response.status = GetDisplayMessagesStatusEnum::Unknown;
         ocpp::CallResult<GetDisplayMessagesResponse> call_result(response, call.uniqueId);
-        this->send<GetDisplayMessagesResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
         return;
     }
 
@@ -3909,18 +3916,18 @@ void ChargePoint::handle_get_display_message(const Call<GetDisplayMessagesReques
     if (messages_request.messageInfo.value().empty()) {
         response.status = GetDisplayMessagesStatusEnum::Unknown;
         ocpp::CallResult<GetDisplayMessagesResponse> call_result(response, call.uniqueId);
-        this->send<GetDisplayMessagesResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
         return;
     } else {
         response.status = GetDisplayMessagesStatusEnum::Accepted;
         ocpp::CallResult<GetDisplayMessagesResponse> call_result(response, call.uniqueId);
-        this->send<GetDisplayMessagesResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
     }
 
     // Send display messages. The response is empty, so we don't have to get that back.
     // Sending multiple messages is not supported for now, because there is no need to split them up (yet).
     ocpp::Call<NotifyDisplayMessagesRequest> request(messages_request, this->message_queue->createMessageId());
-    this->send<NotifyDisplayMessagesRequest>(request);
+    this->message_dispatcher->dispatch_call(request);
 }
 
 void ChargePoint::handle_set_display_message(const Call<SetDisplayMessageRequest> call) {
@@ -3928,7 +3935,7 @@ void ChargePoint::handle_set_display_message(const Call<SetDisplayMessageRequest
     if (!this->callbacks.set_display_message_callback.has_value()) {
         response.status = DisplayMessageStatusEnum::Rejected;
         ocpp::CallResult<SetDisplayMessageResponse> call_result(response, call.uniqueId);
-        this->send<SetDisplayMessageResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
         return;
     }
 
@@ -3992,14 +3999,14 @@ void ChargePoint::handle_set_display_message(const Call<SetDisplayMessageRequest
 
     if (error) {
         ocpp::CallResult<SetDisplayMessageResponse> call_result(response, call.uniqueId);
-        this->send<SetDisplayMessageResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
         return;
     }
 
     const DisplayMessage message = message_info_to_display_message(call.msg.message);
     response = this->callbacks.set_display_message_callback.value()({message});
     ocpp::CallResult<SetDisplayMessageResponse> call_result(response, call.uniqueId);
-    this->send<SetDisplayMessageResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_clear_display_message(const Call<ClearDisplayMessageRequest> call) {
@@ -4008,12 +4015,12 @@ void ChargePoint::handle_clear_display_message(const Call<ClearDisplayMessageReq
         EVLOG_error << "Received a clear display message request, but callback is not implemented.";
         response.status = ClearMessageStatusEnum::Unknown;
         ocpp::CallResult<ClearDisplayMessageResponse> call_result(response, call.uniqueId);
-        this->send<ClearDisplayMessageResponse>(call_result);
+        this->message_dispatcher->dispatch_call_result(call_result);
     }
 
     response = this->callbacks.clear_display_message_callback.value()(call.msg);
     ocpp::CallResult<ClearDisplayMessageResponse> call_result(response, call.uniqueId);
-    this->send<ClearDisplayMessageResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_data_transfer_req(Call<DataTransferRequest> call) {
@@ -4028,51 +4035,7 @@ void ChargePoint::handle_data_transfer_req(Call<DataTransferRequest> call) {
     }
 
     ocpp::CallResult<DataTransferResponse> call_result(response, call.uniqueId);
-    this->send<DataTransferResponse>(call_result);
-}
-
-template <class T> bool ChargePoint::send(ocpp::Call<T> call, const bool initiated_by_trigger_message) {
-    const auto message_type = conversions::string_to_messagetype(json(call).at(CALL_ACTION));
-    const auto message_transmission_priority = get_message_transmission_priority(
-        is_boot_notification_message(message_type), initiated_by_trigger_message,
-        (this->registration_status == RegistrationStatusEnum::Accepted), is_transaction_message(message_type),
-        this->device_model->get_optional_value<bool>(ControllerComponentVariables::QueueAllMessages).value_or(false));
-    switch (message_transmission_priority) {
-    case MessageTransmissionPriority::SendImmediately:
-        this->message_queue->push(call);
-        return true;
-    case MessageTransmissionPriority::SendAfterRegistrationStatusAccepted:
-        this->message_queue->push(call, true);
-        return true;
-    case MessageTransmissionPriority::Discard:
-        return false;
-    }
-    throw std::runtime_error("Missing handling for MessageTransmissionPriority");
-}
-
-template <class T> std::future<EnhancedMessage<v201::MessageType>> ChargePoint::send_async(ocpp::Call<T> call) {
-    const auto message_type = conversions::string_to_messagetype(json(call).at(CALL_ACTION));
-    const auto message_transmission_priority = get_message_transmission_priority(
-        is_boot_notification_message(message_type), false,
-        (this->registration_status == RegistrationStatusEnum::Accepted), is_transaction_message(message_type),
-        this->device_model->get_optional_value<bool>(ControllerComponentVariables::QueueAllMessages).value_or(false));
-    switch (message_transmission_priority) {
-    case MessageTransmissionPriority::SendImmediately:
-        return this->message_queue->push_async(call);
-    case MessageTransmissionPriority::SendAfterRegistrationStatusAccepted:
-    case MessageTransmissionPriority::Discard:
-        auto promise = std::promise<EnhancedMessage<MessageType>>();
-        auto enhanced_message = EnhancedMessage<MessageType>();
-        enhanced_message.offline = true;
-        promise.set_value(enhanced_message);
-        return promise.get_future();
-    }
-    throw std::runtime_error("Missing handling for MessageTransmissionPriority");
-}
-
-template <class T> bool ChargePoint::send(ocpp::CallResult<T> call_result) {
-    this->message_queue->push(call_result);
-    return true;
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 std::optional<DataTransferResponse> ChargePoint::data_transfer_req(const CiString<255>& vendorId,
@@ -4091,7 +4054,7 @@ std::optional<DataTransferResponse> ChargePoint::data_transfer_req(const DataTra
     response.status = DataTransferStatusEnum::Rejected;
 
     ocpp::Call<DataTransferRequest> call(request, this->message_queue->createMessageId());
-    auto data_transfer_future = this->send_async<DataTransferRequest>(call);
+    auto data_transfer_future = this->message_dispatcher->dispatch_call_async(call);
 
     if (this->connectivity_manager == nullptr or !this->connectivity_manager->is_websocket_connected()) {
         return std::nullopt;
@@ -4110,7 +4073,7 @@ std::optional<DataTransferResponse> ChargePoint::data_transfer_req(const DataTra
         } catch (const EnumConversionException& e) {
             EVLOG_error << "EnumConversionException during handling of message: " << e.what();
             auto call_error = CallError(enhanced_message.uniqueId, "FormationViolation", e.what(), json({}));
-            this->send(call_error);
+            this->message_dispatcher->dispatch_call_error(call_error);
             return std::nullopt;
         }
     }
@@ -4157,7 +4120,7 @@ void ChargePoint::handle_send_local_authorization_list_req(Call<SendLocalListReq
     }
 
     ocpp::CallResult<SendLocalListResponse> call_result(response, call.uniqueId);
-    this->send<SendLocalListResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::handle_get_local_authorization_list_version_req(Call<GetLocalListVersionRequest> call) {
@@ -4170,7 +4133,7 @@ void ChargePoint::handle_get_local_authorization_list_version_req(Call<GetLocalL
         } catch (const DatabaseException& e) {
             const auto call_error = CallError(call.uniqueId, "InternalError",
                                               "Unable to retrieve LocalListVersion from the database", json({}));
-            this->send(call_error);
+            this->message_dispatcher->dispatch_call_error(call_error);
             return;
         }
     } else {
@@ -4178,7 +4141,7 @@ void ChargePoint::handle_get_local_authorization_list_version_req(Call<GetLocalL
     }
 
     ocpp::CallResult<GetLocalListVersionResponse> call_result(response, call.uniqueId);
-    this->send<GetLocalListVersionResponse>(call_result);
+    this->message_dispatcher->dispatch_call_result(call_result);
 }
 
 void ChargePoint::scheduled_check_client_certificate_expiration() {
diff --git a/lib/ocpp/v201/message_dispatcher.cpp b/lib/ocpp/v201/message_dispatcher.cpp
new file mode 100644
index 000000000..1386d1752
--- /dev/null
+++ b/lib/ocpp/v201/message_dispatcher.cpp
@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+
+#include <ocpp/v201/ctrlr_component_variables.hpp>
+#include <ocpp/v201/message_dispatcher.hpp>
+
+namespace ocpp {
+namespace v201 {
+
+void MessageDispatcher::dispatch_call(const json& call, bool triggered) {
+    const auto message_type = conversions::string_to_messagetype(call.at(CALL_ACTION));
+    const auto message_transmission_priority = get_message_transmission_priority(
+        is_boot_notification_message(message_type), triggered,
+        (this->registration_status == RegistrationStatusEnum::Accepted), is_transaction_message(message_type),
+        this->device_model.get_optional_value<bool>(ControllerComponentVariables::QueueAllMessages).value_or(false));
+    switch (message_transmission_priority) {
+    case MessageTransmissionPriority::SendImmediately:
+        this->message_queue.push_call(call);
+        return;
+    case MessageTransmissionPriority::SendAfterRegistrationStatusAccepted:
+        this->message_queue.push_call(call, true);
+        return;
+    case MessageTransmissionPriority::Discard:
+        return;
+    }
+    throw std::runtime_error("Missing handling for MessageTransmissionPriority");
+}
+
+std::future<ocpp::EnhancedMessage<MessageType>> MessageDispatcher::dispatch_call_async(const json& call,
+                                                                                       bool triggered) {
+    const auto message_type = conversions::string_to_messagetype(call.at(CALL_ACTION));
+    const auto message_transmission_priority = get_message_transmission_priority(
+        is_boot_notification_message(message_type), false,
+        (this->registration_status == RegistrationStatusEnum::Accepted), is_transaction_message(message_type),
+        this->device_model.get_optional_value<bool>(ControllerComponentVariables::QueueAllMessages).value_or(false));
+    switch (message_transmission_priority) {
+    case MessageTransmissionPriority::SendImmediately:
+        return this->message_queue.push_call_async(call);
+    case MessageTransmissionPriority::SendAfterRegistrationStatusAccepted:
+    case MessageTransmissionPriority::Discard:
+        auto promise = std::promise<EnhancedMessage<MessageType>>();
+        auto enhanced_message = EnhancedMessage<MessageType>();
+        enhanced_message.offline = true;
+        promise.set_value(enhanced_message);
+        return promise.get_future();
+    }
+    throw std::runtime_error("Missing handling for MessageTransmissionPriority");
+}
+
+void MessageDispatcher::dispatch_call_result(const json& call_result) {
+    this->message_queue.push_call_result(call_result);
+}
+
+void MessageDispatcher::dispatch_call_error(const json& call_error) {
+    this->message_queue.push_call_error(call_error);
+}
+
+} // namespace v201
+} // namespace ocpp
\ No newline at end of file
diff --git a/tests/lib/ocpp/common/test_message_queue.cpp b/tests/lib/ocpp/common/test_message_queue.cpp
index dbf7f5f21..67e00131f 100644
--- a/tests/lib/ocpp/common/test_message_queue.cpp
+++ b/tests/lib/ocpp/common/test_message_queue.cpp
@@ -202,7 +202,7 @@ class MessageQueueTest : public ::testing::Test {
         call.msg.type = message_type;
         call.msg.data = identifier;
         call.uniqueId = identifier;
-        message_queue->push(call);
+        message_queue->push_call(call);
         return identifier;
     }
 
@@ -246,7 +246,7 @@ TEST_F(MessageQueueTest, test_transactional_message_is_sent) {
     call.msg.type = TestMessageType::TRANSACTIONAL;
     call.msg.data = "test_data";
     call.uniqueId = "0";
-    message_queue->push(call);
+    message_queue->push_call(call);
 
     wait_for_calls();
 }
@@ -261,7 +261,7 @@ TEST_F(MessageQueueTest, test_non_transactional_message_is_sent) {
     call.msg.type = TestMessageType::NON_TRANSACTIONAL;
     call.msg.data = "test_data";
     call.uniqueId = "0";
-    message_queue->push(call);
+    message_queue->push_call(call);
 
     wait_for_calls();
 }
diff --git a/tests/lib/ocpp/v201/mocks/device_model_storage_interface_mock.hpp b/tests/lib/ocpp/v201/mocks/device_model_storage_interface_mock.hpp
index 9dcf872bd..7589dce78 100644
--- a/tests/lib/ocpp/v201/mocks/device_model_storage_interface_mock.hpp
+++ b/tests/lib/ocpp/v201/mocks/device_model_storage_interface_mock.hpp
@@ -24,5 +24,7 @@ class DeviceModelStorageMock : public DeviceModelStorageInterface {
     MOCK_METHOD(ClearMonitoringStatusEnum, clear_variable_monitor, (int, bool));
     MOCK_METHOD(int32_t, clear_custom_variable_monitors, ());
     MOCK_METHOD(void, check_integrity, ());
+    MOCK_METHOD(bool, update_monitoring_reference, (int32_t monitor_id, const std::string& reference_value),
+                (override));
 };
 } // namespace ocpp::v201
diff --git a/tests/lib/ocpp/v201/mocks/message_dispatcher_mock.hpp b/tests/lib/ocpp/v201/mocks/message_dispatcher_mock.hpp
new file mode 100644
index 000000000..73155d41c
--- /dev/null
+++ b/tests/lib/ocpp/v201/mocks/message_dispatcher_mock.hpp
@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2020 - 2024 Pionix GmbH and Contributors to EVerest
+
+#pragma once
+
+#include "gmock/gmock.h"
+
+#include <ocpp/common/message_dispatcher.hpp>
+
+using namespace ocpp::v201;
+
+class MockMessageDispatcher : public ocpp::MessageDispatcherInterface<MessageType> {
+public:
+    MOCK_METHOD(void, dispatch_call, (const json& call, bool triggered), (override));
+    MOCK_METHOD(std::future<ocpp::EnhancedMessage<MessageType>>, dispatch_call_async,
+                (const json& call, bool triggered), (override));
+    MOCK_METHOD(void, dispatch_call_result, (const json& call_result), (override));
+    MOCK_METHOD(void, dispatch_call_error, (const json& call_error), (override));
+};
\ No newline at end of file