diff --git a/src/MqttClientSetup.h b/src/MqttClientSetup.h
index 67f46a0..e2e0f01 100644
--- a/src/MqttClientSetup.h
+++ b/src/MqttClientSetup.h
@@ -17,32 +17,33 @@ the LICENSE file.
 #endif
 
 #include "MqttClient.h"
+#include "MqttVersion.h"
 
-template <typename T>
+template<template <class> class T, class MQTTVERSION>
 class MqttClientSetup : public MqttClient {
  public:
-  T& setKeepAlive(uint16_t keepAlive) {
+  T<MQTTVERSION>& setKeepAlive(uint16_t keepAlive) {
     _keepAlive = keepAlive * 1000;  // s to ms conversion, will also do 16 to 32 bit conversion
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& setClientId(const char* clientId) {
+  T<MQTTVERSION>& setClientId(const char* clientId) {
     _clientId = clientId;
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& setCleanSession(bool cleanSession) {
+  T<MQTTVERSION>& setCleanSession(bool cleanSession) {
     _cleanSession = cleanSession;
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& setCredentials(const char* username, const char* password) {
+  T<MQTTVERSION>& setCredentials(const char* username, const char* password) {
     _username = username;
     _password = password;
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& setWill(const char* topic, uint8_t qos, bool retain, const uint8_t* payload, size_t length) {
+  T<MQTTVERSION>& setWill(const char* topic, uint8_t qos, bool retain, const uint8_t* payload, size_t length) {
     _willTopic = topic;
     _willQos = qos;
     _willRetain = retain;
@@ -52,158 +53,158 @@ class MqttClientSetup : public MqttClient {
     } else {
       _willPayloadLength = length;
     }
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& setWill(const char* topic, uint8_t qos, bool retain, const char* payload) {
+  T<MQTTVERSION>& setWill(const char* topic, uint8_t qos, bool retain, const char* payload) {
     return setWill(topic, qos, retain, reinterpret_cast<const uint8_t*>(payload), strlen(payload));
   }
 
-  T& setServer(IPAddress ip, uint16_t port) {
+  T<MQTTVERSION>& setServer(IPAddress ip, uint16_t port) {
     _ip = ip;
     _port = port;
     _useIp = true;
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& setServer(const char* host, uint16_t port) {
+  T<MQTTVERSION>& setServer(const char* host, uint16_t port) {
     _host = host;
     _port = port;
     _useIp = false;
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& setTimeout(uint16_t timeout) {
+  T<MQTTVERSION>& setTimeout(uint16_t timeout) {
     _timeout = timeout * 1000;  // s to ms conversion, will also do 16 to 32 bit conversion
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& onConnect(espMqttClientTypes::OnConnectCallback callback, uint32_t id = 0) {
+  T<MQTTVERSION>& onConnect(espMqttClientTypes::OnConnectCallback callback, uint32_t id = 0) {
     #if EMC_MULTIPLE_CALLBACKS
     _onConnectCallbacks.emplace_back(callback, id);
     #else
     (void) id;
     _onConnectCallback = callback;
     #endif
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& onDisconnect(espMqttClientTypes::OnDisconnectCallback callback, uint32_t id = 0) {
+  T<MQTTVERSION>& onDisconnect(espMqttClientTypes::OnDisconnectCallback callback, uint32_t id = 0) {
     #if EMC_MULTIPLE_CALLBACKS
     _onDisconnectCallbacks.emplace_back(callback, id);
     #else
     (void) id;
     _onDisconnectCallback = callback;
     #endif
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& onSubscribe(espMqttClientTypes::OnSubscribeCallback callback, uint32_t id = 0) {
+  T<MQTTVERSION>& onSubscribe(espMqttClientTypes::OnSubscribeCallback callback, uint32_t id = 0) {
     #if EMC_MULTIPLE_CALLBACKS
     _onSubscribeCallbacks.emplace_back(callback, id);
     #else
     (void) id;
     _onSubscribeCallback = callback;
     #endif
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& onUnsubscribe(espMqttClientTypes::OnUnsubscribeCallback callback, uint32_t id = 0) {
+  T<MQTTVERSION>& onUnsubscribe(espMqttClientTypes::OnUnsubscribeCallback callback, uint32_t id = 0) {
     #if EMC_MULTIPLE_CALLBACKS
     _onUnsubscribeCallbacks.emplace_back(callback, id);
     #else
     (void) id;
     _onUnsubscribeCallback = callback;
     #endif
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& onMessage(espMqttClientTypes::OnMessageCallback callback, uint32_t id = 0) {
+  T<MQTTVERSION>& onMessage(espMqttClientTypes::OnMessageCallback callback, uint32_t id = 0) {
     #if EMC_MULTIPLE_CALLBACKS
     _onMessageCallbacks.emplace_back(callback, id);
     #else
     (void) id;
     _onMessageCallback = callback;
     #endif
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& onPublish(espMqttClientTypes::OnPublishCallback callback, uint32_t id = 0) {
+  T<MQTTVERSION>& onPublish(espMqttClientTypes::OnPublishCallback callback, uint32_t id = 0) {
     #if EMC_MULTIPLE_CALLBACKS
     _onPublishCallbacks.emplace_back(callback, id);
     #else
     (void) id;
     _onPublishCallback = callback;
     #endif
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
   #if EMC_MULTIPLE_CALLBACKS
-  T& removeOnConnect(uint32_t id) {
+  T<MQTTVERSION>& removeOnConnect(uint32_t id) {
     for (auto it = _onConnectCallbacks.begin(); it != _onConnectCallbacks.end(); ++it) {
       if (it->second == id) {
         _onConnectCallbacks.erase(it);
         break;
       }
     }
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& removeOnDisconnect(uint32_t id) {
+  T<MQTTVERSION>& removeOnDisconnect(uint32_t id) {
     for (auto it = _onDisconnectCallbacks.begin(); it != _onDisconnectCallbacks.end(); ++it) {
       if (it->second == id) {
         _onDisconnectCallbacks.erase(it);
         break;
       }
     }
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& removeOnSubscribe(uint32_t id) {
+  T<MQTTVERSION>& removeOnSubscribe(uint32_t id) {
     for (auto it = _onSubscribeCallbacks.begin(); it != _onSubscribeCallbacks.end(); ++it) {
       if (it->second == id) {
         _onSubscribeCallbacks.erase(it);
         break;
       }
     }
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& removeOnUnsubscribe(uint32_t id) {
+  T<MQTTVERSION>& removeOnUnsubscribe(uint32_t id) {
     for (auto it = _onUnsubscribeCallbacks.begin(); it != _onUnsubscribeCallbacks.end(); ++it) {
       if (it->second == id) {
         _onUnsubscribeCallbacks.erase(it);
         break;
       }
     }
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& removeOnMessage(uint32_t id) {
+  T<MQTTVERSION>& removeOnMessage(uint32_t id) {
     for (auto it = _onMessageCallbacks.begin(); it != _onMessageCallbacks.end(); ++it) {
       if (it->second == id) {
         _onMessageCallbacks.erase(it);
         break;
       }
     }
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
 
-  T& removeOnPublish(uint32_t id) {
+  T<MQTTVERSION>& removeOnPublish(uint32_t id) {
     for (auto it = _onPublishCallbacks.begin(); it != _onPublishCallbacks.end(); ++it) {
       if (it->second == id) {
         _onPublishCallbacks.erase(it);
         break;
       }
     }
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
   #endif
 
   /*
-  T& onError(espMqttClientTypes::OnErrorCallback callback) {
+  T<MQTTVERSION>& onError(espMqttClientTypes::OnErrorCallback callback) {
     _onErrorCallback = callback;
-    return static_cast<T&>(*this);
+    return static_cast<T<MQTTVERSION>&>(*this);
   }
   */
 
diff --git a/src/MqttVersion.h b/src/MqttVersion.h
new file mode 100644
index 0000000..95d6a48
--- /dev/null
+++ b/src/MqttVersion.h
@@ -0,0 +1,25 @@
+/*
+Copyright (c) 2022 Bert Melis. All rights reserved.
+
+This work is licensed under the terms of the MIT license.  
+For a copy, see <https://opensource.org/licenses/MIT> or
+the LICENSE file.
+*/
+
+#pragma once
+
+namespace MqttVersion {
+
+class v3_1 {
+  // empty
+};
+
+class v3_1_1 {
+  // empty
+};
+
+class v5 {
+  // empty
+};
+
+}  // end namespace MqttVersion
diff --git a/src/espMqttClient.cpp b/src/espMqttClient.cpp
deleted file mode 100644
index 833ece1..0000000
--- a/src/espMqttClient.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
-Copyright (c) 2022 Bert Melis. All rights reserved.
-
-This work is licensed under the terms of the MIT license.  
-For a copy, see <https://opensource.org/licenses/MIT> or
-the LICENSE file.
-*/
-
-#include "espMqttClient.h"
-
-#if defined(ARDUINO_ARCH_ESP8266)
-espMqttClient::espMqttClient()
-: MqttClientSetup(espMqttClientTypes::UseInternalTask::NO)
-, _client() {
-  _transport = &_client;
-}
-
-espMqttClientSecure::espMqttClientSecure()
-: MqttClientSetup(espMqttClientTypes::UseInternalTask::NO)
-, _client() {
-  _transport = &_client;
-}
-
-espMqttClientSecure& espMqttClientSecure::setInsecure() {
-  _client.client.setInsecure();
-  return *this;
-}
-
-espMqttClientSecure& espMqttClientSecure::setFingerprint(const uint8_t fingerprint[20]) {
-  _client.client.setFingerprint(fingerprint);
-  return *this;
-}
-
-espMqttClientSecure& espMqttClientSecure::setTrustAnchors(const X509List *ta) {
-  _client.client.setTrustAnchors(ta);
-  return *this;
-}
-
-espMqttClientSecure& espMqttClientSecure::setClientRSACert(const X509List *cert, const PrivateKey *sk) {
-  _client.client.setClientRSACert(cert, sk);
-  return *this;
-}
-
-espMqttClientSecure& espMqttClientSecure::setClientECCert(const X509List *cert, const PrivateKey *sk, unsigned allowed_usages, unsigned cert_issuer_key_type) {
-  _client.client.setClientECCert(cert, sk, allowed_usages, cert_issuer_key_type);
-  return *this;
-}
-
-espMqttClientSecure& espMqttClientSecure::setCertStore(CertStoreBase *certStore) {
-  _client.client.setCertStore(certStore);
-  return *this;
-}
-#endif
-
-#if defined(ARDUINO_ARCH_ESP32)
-espMqttClient::espMqttClient(espMqttClientTypes::UseInternalTask useInternalTask)
-: MqttClientSetup(useInternalTask)
-, _client() {
-  _transport = &_client;
-}
-
-espMqttClient::espMqttClient(uint8_t priority, uint8_t core)
-: MqttClientSetup(espMqttClientTypes::UseInternalTask::YES, priority, core)
-, _client() {
-  _transport = &_client;
-}
-
-espMqttClientSecure::espMqttClientSecure(espMqttClientTypes::UseInternalTask useInternalTask)
-: MqttClientSetup(useInternalTask)
-, _client() {
-  _transport = &_client;
-}
-
-espMqttClientSecure::espMqttClientSecure(uint8_t priority, uint8_t core)
-: MqttClientSetup(espMqttClientTypes::UseInternalTask::YES, priority, core)
-, _client() {
-  _transport = &_client;
-}
-
-espMqttClientSecure& espMqttClientSecure::setInsecure() {
-  _client.client.setInsecure();
-  return *this;
-}
-
-espMqttClientSecure& espMqttClientSecure::setCACert(const char* rootCA) {
-  _client.client.setCACert(rootCA);
-  return *this;
-}
-
-espMqttClientSecure& espMqttClientSecure::setCertificate(const char* clientCa) {
-  _client.client.setCertificate(clientCa);
-  return *this;
-}
-
-espMqttClientSecure& espMqttClientSecure::setPrivateKey(const char* privateKey) {
-  _client.client.setPrivateKey(privateKey);
-  return *this;
-}
-
-espMqttClientSecure& espMqttClientSecure::setPreSharedKey(const char* pskIdent, const char* psKey) {
-  _client.client.setPreSharedKey(pskIdent, psKey);
-  return *this;
-}
-
-#endif
-
-#if defined(__linux__)
-espMqttClient::espMqttClient()
-: MqttClientSetup(espMqttClientTypes::UseInternalTask::NO)
-, _client() {
-  _transport = &_client;
-}
-#endif
diff --git a/src/espMqttClient.h b/src/espMqttClient.h
index 4e44801..a712bc4 100644
--- a/src/espMqttClient.h
+++ b/src/espMqttClient.h
@@ -21,23 +21,58 @@ the LICENSE file.
 #include "MqttClientSetup.h"
 
 #if defined(ARDUINO_ARCH_ESP8266)
-class espMqttClient : public MqttClientSetup<espMqttClient> {
+
+template<class MQTTVERSION>
+class espMqttClient : public MqttClientSetup<espMqttClient, MQTTVERSION> {
  public:
-  espMqttClient();
+  espMqttClient()
+  : MqttClientSetup<espMqttClient, MQTTVERSION>(espMqttClientTypes::UseInternalTask::NO)
+  , _client() {
+    MqttClient::_transport = &_client;
+  }
 
  protected:
   espMqttClientInternals::ClientSync _client;
 };
 
-class espMqttClientSecure : public MqttClientSetup<espMqttClientSecure> {
+template<class MQTTVERSION>
+class espMqttClientSecure : public MqttClientSetup<espMqttClientSecure, MQTTVERSION> {
  public:
-  espMqttClientSecure();
-  espMqttClientSecure& setInsecure();
-  espMqttClientSecure& setFingerprint(const uint8_t fingerprint[20]);
-  espMqttClientSecure& setTrustAnchors(const X509List *ta);
-  espMqttClientSecure& setClientRSACert(const X509List *cert, const PrivateKey *sk);
-  espMqttClientSecure& setClientECCert(const X509List *cert, const PrivateKey *sk, unsigned allowed_usages, unsigned cert_issuer_key_type);
-  espMqttClientSecure& setCertStore(CertStoreBase *certStore);
+  espMqttClientSecure()
+  : MqttClientSetup<espMqttClientSecure, MQTTVERSION>(espMqttClientTypes::UseInternalTask::NO)
+  , _client() {
+    MqttClient::_transport = &_client;
+  }
+
+  espMqttClientSecure& setInsecure() {
+    _client.client.setInsecure();
+    return *this;
+  }
+
+  espMqttClientSecure& setFingerprint(const uint8_t fingerprint[20]) {
+    _client.client.setFingerprint(fingerprint);
+    return *this;
+  }
+
+  espMqttClientSecure& setTrustAnchors(const X509List *ta) {
+    _client.client.setTrustAnchors(ta);
+    return *this;
+  }
+
+  espMqttClientSecure& setClientRSACert(const X509List *cert, const PrivateKey *sk) {
+    _client.client.setClientRSACert(cert, sk);
+    return *this;
+  }
+
+  espMqttClientSecure& setClientECCert(const X509List *cert, const PrivateKey *sk, unsigned allowed_usages, unsigned cert_issuer_key_type) {
+    _client.client.setClientECCert(cert, sk, allowed_usages, cert_issuer_key_type);
+    return *this;
+  }
+
+  espMqttClientSecure& setCertStore(CertStoreBase *certStore) {
+    _client.client.setCertStore(certStore);
+    return *this;
+  }
 
  protected:
   espMqttClientInternals::ClientSecureSync _client;
@@ -45,24 +80,64 @@ class espMqttClientSecure : public MqttClientSetup<espMqttClientSecure> {
 #endif
 
 #if defined(ARDUINO_ARCH_ESP32)
-class espMqttClient : public MqttClientSetup<espMqttClient> {
+template<class MQTTVERSION>
+class espMqttClient : public MqttClientSetup<espMqttClient, MQTTVERSION> {
  public:
-  explicit espMqttClient(espMqttClientTypes::UseInternalTask useInternalTask);
-  explicit espMqttClient(uint8_t priority = 1, uint8_t core = 1);
+  explicit espMqttClient(espMqttClientTypes::UseInternalTask useInternalTask)
+  : MqttClientSetup<espMqttClient, MQTTVERSION>(useInternalTask)
+  , _client() {
+    MqttClient::_transport = &_client;
+  }
+
+  explicit espMqttClient(uint8_t priority = 1, uint8_t core = 1)
+  : MqttClientSetup<espMqttClient, MQTTVERSION>(espMqttClientTypes::UseInternalTask::YES, priority, core)
+  , _client() {
+    MqttClient::_transport = &_client;
+  }
 
  protected:
   espMqttClientInternals::ClientSync _client;
 };
 
-class espMqttClientSecure : public MqttClientSetup<espMqttClientSecure> {
+template<class MQTTVERSION>
+class espMqttClientSecure : public MqttClientSetup<espMqttClientSecure, MQTTVERSION> {
  public:
-  explicit espMqttClientSecure(espMqttClientTypes::UseInternalTask useInternalTask);
-  explicit espMqttClientSecure(uint8_t priority = 1, uint8_t core = 1);
-  espMqttClientSecure& setInsecure();
-  espMqttClientSecure& setCACert(const char* rootCA);
-  espMqttClientSecure& setCertificate(const char* clientCa);
-  espMqttClientSecure& setPrivateKey(const char* privateKey);
-  espMqttClientSecure& setPreSharedKey(const char* pskIdent, const char* psKey);
+  explicit espMqttClientSecure(espMqttClientTypes::UseInternalTask useInternalTask)
+  : MqttClientSetup<espMqttClientSecure, MQTTVERSION>(useInternalTask)
+  , _client() {
+    MqttClient::_transport = &_client;
+  }
+
+  explicit espMqttClientSecure(uint8_t priority = 1, uint8_t core = 1)
+  : MqttClientSetup<espMqttClientSecure, MQTTVERSION>(espMqttClientTypes::UseInternalTask::YES, priority, core)
+  , _client() {
+    MqttClient::_transport = &_client;
+  }
+
+  espMqttClientSecure& setInsecure() {
+    _client.client.setInsecure();
+    return *this;
+  }
+
+  espMqttClientSecure& setCACert(const char* rootCA) {
+    _client.client.setCACert(rootCA);
+    return *this;
+  }
+
+  espMqttClientSecure& setCertificate(const char* clientCa) {
+    _client.client.setCertificate(clientCa);
+    return *this;
+  }
+
+  espMqttClientSecure& setPrivateKey(const char* privateKey) {
+    _client.client.setPrivateKey(privateKey);
+    return *this;
+  }
+
+  espMqttClientSecure& esetPreSharedKey(const char* pskIdent, const char* psKey) {
+    _client.client.setPreSharedKey(pskIdent, psKey);
+    return *this;
+  }
 
  protected:
   espMqttClientInternals::ClientSecureSync _client;
@@ -70,11 +145,19 @@ class espMqttClientSecure : public MqttClientSetup<espMqttClientSecure> {
 #endif
 
 #if defined(__linux__)
-class espMqttClient : public MqttClientSetup<espMqttClient> {
+template<class MQTTVERSION>
+class espMqttClient : public MqttClientSetup<espMqttClient, MQTTVERSION> {
  public:
-  espMqttClient();
+  espMqttClient()
+  : MqttClientSetup<espMqttClient, MQTTVERSION>(espMqttClientTypes::UseInternalTask::NO)
+  , _client() {
+    MqttClient::_transport = &_client;
+  }
 
  protected:
   espMqttClientInternals::ClientPosix _client;
 };
 #endif
+
+#define espMqttClient espMqttClient<MqttVersion::v3_1_1>
+#define espMqttClientSecure espMqttClientSecure<MqttVersion::v3_1_1>
diff --git a/src/espMqttClientAsync.cpp b/src/espMqttClientAsync.cpp
deleted file mode 100644
index 98b7f15..0000000
--- a/src/espMqttClientAsync.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-Copyright (c) 2022 Bert Melis. All rights reserved.
-
-This work is licensed under the terms of the MIT license.  
-For a copy, see <https://opensource.org/licenses/MIT> or
-the LICENSE file.
-*/
-
-#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
-
-#include "espMqttClientAsync.h"
-
-espMqttClientAsync::espMqttClientAsync()
-: MqttClientSetup(espMqttClientTypes::UseInternalTask::NO)
-, _clientAsync() {
-  _transport = &_clientAsync;
-  _clientAsync.client.onConnect(onConnectCb, this);
-  _clientAsync.client.onDisconnect(onDisconnectCb, this);
-  _clientAsync.client.onData(onDataCb, this);
-  _clientAsync.client.onPoll(onPollCb, this);
-}
-
-bool espMqttClientAsync::connect() {
-  bool ret = MqttClient::connect();
-  loop();
-  return ret;
-}
-
-void espMqttClientAsync::_setupClient(espMqttClientAsync* c) {
-  (void)c;
-}
-
-void espMqttClientAsync::onConnectCb(void* a, AsyncClient* c) {
-  c->setNoDelay(true);
-  espMqttClientAsync* client = reinterpret_cast<espMqttClientAsync*>(a);
-  client->_state = MqttClient::State::connectingTcp2;
-  client->loop();
-}
-
-void espMqttClientAsync::onDataCb(void* a, AsyncClient* c, void* data, size_t len) {
-  (void)c;
-  espMqttClientAsync* client = reinterpret_cast<espMqttClientAsync*>(a);
-  client->_clientAsync.bufData = reinterpret_cast<uint8_t*>(data);
-  client->_clientAsync.availableData = len;
-  client->loop();
-}
-
-void espMqttClientAsync::onDisconnectCb(void* a, AsyncClient* c) {
-  (void)c;
-  espMqttClientAsync* client = reinterpret_cast<espMqttClientAsync*>(a);
-  client->_state = MqttClient::State::disconnectingTcp2;
-  client->loop();
-}
-
-void espMqttClientAsync::onPollCb(void* a, AsyncClient* c) {
-  (void)c;
-  espMqttClientAsync* client = reinterpret_cast<espMqttClientAsync*>(a);
-  client->loop();
-}
-
-#endif
diff --git a/src/espMqttClientAsync.h b/src/espMqttClientAsync.h
index 1b9ed8b..97b8162 100644
--- a/src/espMqttClientAsync.h
+++ b/src/espMqttClientAsync.h
@@ -17,20 +17,61 @@ the LICENSE file.
 
 #include "MqttClientSetup.h"
 
-class espMqttClientAsync : public MqttClientSetup<espMqttClientAsync> {
+template<class MQTTVERSION>
+class espMqttClientAsync : public MqttClientSetup<espMqttClientAsync, MQTTVERSION> {
  public:
-  espMqttClientAsync();
-  bool connect();
+  espMqttClientAsync()
+  : MqttClientSetup<espMqttClientAsync, MQTTVERSION>(espMqttClientTypes::UseInternalTask::NO)
+  , _clientAsync() {
+    MqttClient::_transport = &_clientAsync;
+    _clientAsync.client.onConnect(onConnectCb, this);
+    _clientAsync.client.onDisconnect(onDisconnectCb, this);
+    _clientAsync.client.onData(onDataCb, this);
+    _clientAsync.client.onPoll(onPollCb, this);
+  }
+
+  bool connect() {
+    bool ret = MqttClient::connect();
+    loop();
+    return ret;
+  }
 
  protected:
   espMqttClientInternals::ClientAsync _clientAsync;
-  static void _setupClient(espMqttClientAsync* c);
-  static void _disconnectClient(espMqttClientAsync* c);
 
-  static void onConnectCb(void* a, AsyncClient* c);
-  static void onDataCb(void* a, AsyncClient* c, void* data, size_t len);
-  static void onDisconnectCb(void* a, AsyncClient* c);
-  static void onPollCb(void* a, AsyncClient* c);
+  static void _setupClient(espMqttClientAsync* c) {
+    (void)c;
+  }
+
+  static void onConnectCb(void* a, AsyncClient* c) {
+    c->setNoDelay(true);
+    espMqttClientAsync* client = reinterpret_cast<espMqttClientAsync*>(a);
+    client->_state = MqttClient::State::connectingTcp2;
+    client->loop();
+  }
+
+  static void onDataCb(void* a, AsyncClient* c, void* data, size_t len) {
+    (void)c;
+    espMqttClientAsync* client = reinterpret_cast<espMqttClientAsync*>(a);
+    client->_clientAsync.bufData = reinterpret_cast<uint8_t*>(data);
+    client->_clientAsync.availableData = len;
+    client->loop();
+  }
+
+  static void onDisconnectCb(void* a, AsyncClient* c) {
+    (void)c;
+    espMqttClientAsync* client = reinterpret_cast<espMqttClientAsync*>(a);
+    client->_state = MqttClient::State::disconnectingTcp2;
+    client->loop();
+  }
+
+  static void onPollCb(void* a, AsyncClient* c) {
+    (void)c;
+    espMqttClientAsync* client = reinterpret_cast<espMqttClientAsync*>(a);
+    client->loop();
+  }
 };
 
 #endif
+
+#define espMqttClientAsync espMqttClientAsync<MqttVersion::v3_1_1>