diff --git a/docs/user-guide/amqp-adapter/index.html b/docs/user-guide/amqp-adapter/index.html
index fa03eb2..93828d8 100644
--- a/docs/user-guide/amqp-adapter/index.html
+++ b/docs/user-guide/amqp-adapter/index.html
@@ -21,19 +21,19 @@
     <title>AMQP Adapter :: Eclipse Hono&trade;</title>
 
     
-    <link href="/hono/docs/css/nucleus.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/fontawesome-all.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hybrid.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/featherlight.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/auto-complete.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/theme.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hugo-theme.css?1595208214" rel="stylesheet">
+    <link href="/hono/docs/css/nucleus.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/fontawesome-all.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hybrid.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/featherlight.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/auto-complete.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/theme.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hugo-theme.css?1595294628" rel="stylesheet">
     
-      <link href="/hono/docs/css/theme-hono.css?1595208214" rel="stylesheet">
+      <link href="/hono/docs/css/theme-hono.css?1595294628" rel="stylesheet">
     
 
-    <script src="/hono/docs/js/jquery-2.x.min.js?1595208214"></script>
+    <script src="/hono/docs/js/jquery-2.x.min.js?1595294628"></script>
 
     <style type="text/css">
       :root #header + #content > #left > #rlblock_left{
@@ -83,14 +83,14 @@
     <span data-search-clear=""><i class="fas fa-times"></i></span>
 </div>
 
-<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595208214"></script>
-<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595294628"></script>
+<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595294628"></script>
 <script type="text/javascript">
     
         var baseurl = "https:\/\/www.eclipse.org\/hono\/docs\/";
     
 </script>
-<script type="text/javascript" src="/hono/docs/js/search.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/search.js?1595294628"></script>
 
     
   </div>
@@ -315,9 +315,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/user-guide/device-registry/" title="Device Registry" class="dd-item ">
-        <a href="/hono/docs/user-guide/device-registry/">
-        Device Registry
+      <li data-nav-id="/hono/docs/user-guide/mongodb-based-device-registry/" title="MongoDB Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/mongodb-based-device-registry/">
+        MongoDB Based Device Registry
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/user-guide/file-based-device-registry/" title="File Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/file-based-device-registry/">
+        File Based Device Registry
         
         </a>
     </li>
@@ -537,9 +556,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/device-registry-config/" title="Device Registry Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/device-registry-config/">
-        Device Registry Configuration
+      <li data-nav-id="/hono/docs/admin-guide/mongodb-device-registry-config/" title="MongoDB Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mongodb-device-registry-config/">
+        MongoDB Based Device Registry Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/admin-guide/file-based-device-registry-config/" title="File Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/file-based-device-registry-config/">
+        File Based Device Registry Configuration
         
         </a>
     </li>
@@ -594,6 +632,25 @@
  
   
     
+      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
+        MQTT Adapter Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
       <li data-nav-id="/hono/docs/admin-guide/amqp-adapter-config/" title="AMQP Adapter Configuration" class="dd-item ">
         <a href="/hono/docs/admin-guide/amqp-adapter-config/">
         AMQP Adapter Configuration
@@ -613,9 +670,9 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
-        MQTT Adapter Configuration
+      <li data-nav-id="/hono/docs/admin-guide/coap-adapter-config/" title="CoAP Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/coap-adapter-config/">
+        CoAP Adapter Configuration
         
         </a>
     </li>
@@ -1277,7 +1334,27 @@
                   
                     
                     
-                      <option id="stable" value="/hono/docs/user-guide/amqp-adapter/" selected>stable (1.2)</option>
+                      <option id="stable" value="/hono/docs/user-guide/amqp-adapter/" selected>stable (1.3)</option>
+                    
+                  
+              
+                  
+              
+                  
+              
+                  
+              
+                  
+              
+          
+              
+              
+                  
+              
+                  
+                    
+                    
+                      <option id="1.2" value="/hono/docs/1.2/user-guide/amqp-adapter/">1.2</option>
                     
                   
               
@@ -1293,6 +1370,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="1.1" value="/hono/docs/1.1/user-guide/amqp-adapter/">1.1</option>
@@ -1311,6 +1390,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="1.0" value="/hono/docs/1.0/user-guide/amqp-adapter/">1.0</option>
@@ -1329,6 +1410,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="dev" value="/hono/docs/dev/user-guide/amqp-adapter/">dev</option>
@@ -1456,7 +1539,7 @@
 <li><a href="#connection-duration-limits">Connection Duration Limits</a></li>
 <li><a href="#message-limits">Message Limits</a></li>
 </ul></li>
-<li><a href="#connection-event">Connection Event</a></li>
+<li><a href="#connection-events">Connection Events</a></li>
 <li><a href="#link-establishment">Link Establishment</a></li>
 <li><a href="#error-handling">Error Handling</a></li>
 <li><a href="#amqp-command-line-client">AMQP Command-line Client</a></li>
@@ -1503,62 +1586,82 @@
 
 <h2 id="device-authentication">Device Authentication</h2>
 
-<p>By default, all Hono protocol adapters require clients (devices or gateway components) to authenticate during connection establishment. This is the preferred way for devices to publish data via protocol adapters. The AMQP adapter supports both the <a href="https://tools.ietf.org/html/rfc4616">SASL PLAIN</a> and <a href="https://tools.ietf.org/html/rfc4422">SASL EXTERNAL</a> authentication mechanisms. The former uses a <em>username</em> and <em>password</em> to authenticate to the adapter while the latter uses a client certificate.</p>
+<p>By default, all Hono protocol adapters require clients (devices or gateway components) to authenticate during connection establishment.
+This is the preferred way for devices to publish data via protocol adapters. The AMQP adapter supports both the
+<a href="https://tools.ietf.org/html/rfc4616">SASL PLAIN</a> and <a href="https://tools.ietf.org/html/rfc4422">SASL EXTERNAL</a> authentication mechanisms.
+The former uses a <em>username</em> and <em>password</em> to authenticate to the adapter while the latter uses an X.509 client certificate.</p>
 
-<p>In this guide, we will give examples for publishing telemetry data and events for <em>authenticated</em> (using SASL PLAIN) and <em>unauthenticated</em> clients.</p>
+<p>This guide provides examples for publishing telemetry and events for <em>authenticated</em> (using SASL PLAIN) and <em>unauthenticated</em> clients.</p>
 
-<p><strong>NB</strong> The AMQP adapter can be configured to <em>allow</em> unauthenticated devices to connect by setting configuration variable <code>HONO_AMQP_AUTHENTICATION_REQUIRED</code> to <code>false</code>.</p>
+<p><strong>NB</strong> The AMQP adapter can be configured to <em>allow</em> unauthenticated devices to connect by setting configuration variable
+<code>HONO_AMQP_AUTHENTICATION_REQUIRED</code> to <code>false</code>.</p>
 
 <h3 id="sasl-plain-authentication">SASL PLAIN Authentication</h3>
 
-<p>The AMQP adapter supports authenticating clients using a <em>username</em> and <em>password</em>. This means that clients need to provide a <em>username</em> and a <em>password</em> when connecting to the AMQP adapter. If the adapter is configured for multi-tenancy (i.e <code>HONO_AMQP_SINGLE_TENANT</code> is set to <code>false</code>), then the <em>username</em> must match the pattern [<em>auth-id@tenant</em>], e.g. <code>sensor1@DEFAULT_TENANT</code>. Otherwise the <code>DEFAULT_TENANT</code> is assumed and the tenant-id can be omitted from the username.</p>
+<p>The AMQP adapter supports authenticating clients using a <em>username</em> and <em>password</em>. This means that clients need to provide a <em>username</em> and a <em>password</em>
+when connecting to the AMQP adapter. If the adapter is configured for multi-tenancy (i.e <code>HONO_AMQP_SINGLE_TENANT</code> is set to <code>false</code>),
+then the <em>username</em> must match the pattern [<em>auth-id@tenant</em>], e.g. <code>sensor1@DEFAULT_TENANT</code>. Otherwise, the tenant-id can be omitted from the username
+and the client is assumed to belong to the <code>DEFAULT_TENANT</code>.</p>
 
-<p>The adapter verifies the credentials provided by the client against the credentials the <a href="/hono/docs/admin-guide/common-config/#credentials-service-connection-configuration">configured Credentials service</a> has on record for the client. If the credentials match, then authentication is successful and the client device can proceed to publish messages to Hono.</p>
+<p>The adapter verifies the credentials provided by the client against the credentials that the
+<a href="/hono/docs/admin-guide/common-config/#credentials-service-connection-configuration">configured Credentials service</a> has on record for the client.
+If the credentials match, the client device can proceed to publish messages to Hono.</p>
 
-<p>The examples below refer to devices <code>4711</code> and <code>gw-1</code> of tenant <code>DEFAULT_TENANT</code> using <em>auth-ids</em> <code>sensor1</code> and <code>gw1</code> and corresponding passwords. The example deployment as described in the <a href="/hono/docs/deployment/">Deployment Guides</a> comes pre-configured with the corresponding entities in its device registry component.</p>
+<p>The examples below refer to devices <code>4711</code> and <code>gw-1</code> of tenant <code>DEFAULT_TENANT</code> using <em>auth-ids</em> <code>sensor1</code> and <code>gw1</code> and corresponding passwords.
+The example deployment as described in the <a href="/hono/docs/deployment/">Deployment Guide</a> comes pre-configured with the corresponding entities in its
+device registry component.</p>
 
-<p><strong>NB</strong> There is a subtle difference between the <em>device identifier</em> (<em>device-id</em>) and the <em>auth-id</em> a device uses for authentication. See <a href="/hono/docs/concepts/device-identity/">Device Identity</a> for a discussion of the concepts.</p>
+<p><strong>NB</strong> There is a subtle difference between the <em>device identifier</em> (<em>device-id</em>) and the <em>auth-id</em> a device uses for authentication.
+See <a href="/hono/docs/concepts/device-identity/">Device Identity</a> for a discussion of the concepts.</p>
 
 <h3 id="sasl-external-authentication">SASL EXTERNAL Authentication</h3>
 
-<p>When a device uses a client certificate for authentication, the TLS handshake is initiated during TCP connection establishment. If no trust anchor is configured for the AMQP adapter, the TLS handshake will succeed only if the certificate has not yet expired. Once the TLS handshake completes and a secure connection is established, the certificate&rsquo;s signature is checked during the SASL handshake. To complete the SASL handshake and authenticate the client, the adapter performs the following steps:</p>
+<p>When a device uses a client certificate for authentication, the TLS handshake is initiated during TCP connection establishment.
+If no trust anchor is configured for the AMQP adapter, the TLS handshake will succeed only if the certificate has not yet expired.
+Once the TLS handshake completes and a secure connection is established, the certificate&rsquo;s signature is checked during the SASL handshake.
+To complete the SASL handshake and authenticate the client, the adapter performs the following steps:</p>
 
-<ul>
-<li>Adapter extracts the client certificate&rsquo;s <em>Issuer DN</em> and uses it to</li>
-<li>us the Tenant service to look up the tenant that the client belongs to. In order for the lookup to succeed, the tenant’s trust anchor needs to be configured by means of registering the <a href="/hono/docs/api/tenant/#trusted-ca-format">trusted certificate authority</a>.</li>
-<li>If the lookup succeeds, the Tenant service returns the tenant, thus implicitly establishing the tenant that the device belongs to.</li>
-<li>Adapter validates the device’s client certificate using the registered trust anchor for the tenant.</li>
-<li>Finally, adapter authenticates the client certificate using Hono&rsquo;s credentials API. In this step, the adapter uses the client certificate’s <em>Subject DN</em> (as authentication identifier) and <code>x509-cert</code> (for the credentials type) in order to determine the device ID.</li>
-</ul>
+<ol>
+<li>The adapter extracts the client certificate&rsquo;s <em>Issuer DN</em> from the client certificate</li>
+<li>The adapter invokes the Tenant service to look up the tenant matching the DN.
+In order for the lookup to succeed, the tenant’s trust anchor needs to be configured by means of registering the
+<a href="/hono/docs/api/tenant/#trusted-ca-format">trusted certificate authority</a>.</li>
+<li>If the lookup succeeds, the tenant returned by the Tenant service is the tenant that the device belongs to.</li>
+<li>The adapter verifies the device’s client certificate&rsquo;s signature using the trust anchor registered for the tenant.</li>
+<li>Finally, the adapter authenticates the client certificate using Hono&rsquo;s credentials API. In this step, the adapter
+uses the client certificate’s <em>Subject DN</em> (as authentication identifier) and <code>x509-cert</code> (for the credentials type)
+in order to determine the device ID.</li>
+</ol>
 
 <p><strong>NB</strong> The AMQP adapter needs to be configured for TLS in order to support this mechanism.</p>
 
 <h2 id="resource-limit-checks">Resource Limit Checks</h2>
 
-<p>The adapter performs additional checks regarding <a href="/hono/docs/concepts/resource-limits/">resource limits</a> when a client tries to connect and/or
-send a message to the adapter.</p>
+<p>The adapter performs additional checks regarding resource limits when a client tries to connect and/or send a message to the adapter.</p>
 
 <h3 id="connection-limits">Connection Limits</h3>
 
-<p>The adapter fails the SASL handshake with a client</p>
+<p>The adapter immediately closes a newly established connection with an <code>amqp:unauthorized-access</code> error if</p>
 
 <ul>
-<li>if the maximum number of simultaneously connected devices for the client&rsquo;s tenant is reached, or</li>
-<li>if the maximum number of connections per protocol adapter instance is reached.</li>
+<li>the maximum number of connections per protocol adapter instance is reached, or</li>
+<li>if the maximum number of simultaneously connected devices for the client&rsquo;s tenant is reached.</li>
 </ul>
 
+<p>Please refer to <a href="/hono/docs/concepts/resource-limits/">resource-limits</a> for details.</p>
+
 <h3 id="connection-duration-limits">Connection Duration Limits</h3>
 
-<p>The adapter fails the SASL handshake with a client if the
-<a href="/hono/docs/concepts/resource-limits/#connection-duration-limit">connection duration limit</a> that has been configured
-for the client’s tenant is exceeded.</p>
+<p>The adapter immediately closes a newly established connection with an <code>amqp:unauthorized-access</code> error if the
+<a href="/hono/docs/concepts/resource-limits/#connection-duration-limit">connection duration limit</a> that has been configured for
+the client&rsquo;s tenant is exceeded.</p>
 
 <h3 id="message-limits">Message Limits</h3>
 
 <p>The adapter</p>
 
 <ul>
-<li>fails the SASL handshake with a client and</li>
+<li>immediately closes a newly established connection with an <code>amqp:unauthorized-access</code> error and</li>
 <li>rejects any AMQP 1.0 message containing
 
 <ul>
@@ -1567,11 +1670,15 @@
 </ul></li>
 </ul>
 
-<p>if the <a href="/hono/docs/concepts/resource-limits/">message limit</a> that has been configured for the device’s tenant is exceeded.</p>
+<p>if the <a href="/hono/docs/concepts/resource-limits/">message limit</a> that has been configured for the device&rsquo;s tenant is exceeded.</p>
 
-<h2 id="connection-event">Connection Event</h2>
+<h2 id="connection-events">Connection Events</h2>
 
-<p>The AMQP Adapter can send a <a href="/hono/docs/api/event/#connection-event">Connection Event</a> once the connection with a device has been successfully established or ended. Note that this requires the <a href="/hono/docs/admin-guide/mqtt-adapter-config/#service-configuration"><code>HONO_CONNECTION_EVENTS_PRODUCER</code></a> configuration property to be explicitly set to <code>events</code>.</p>
+<p>The adapter can emit <a href="/hono/docs/api/event/#connection-event">Connection Events</a> for client connections being established and/or terminated.
+Please refer to the <a href="/hono/docs/admin-guide/common-config/#connection-event-producer-configuration">common configuration options</a>
+for details regarding how to enable this behavior.</p>
+
+<p>The adapter includes the client&rsquo;s AMQP <em>container-id</em> as the Connection Event&rsquo;s <em>remote-id</em>.</p>
 
 <h2 id="link-establishment">Link Establishment</h2>
 
@@ -1934,7 +2041,7 @@
 </tbody>
 </table>
 
-<p>Authenticated gateways will receive commands for devices which do not connect to a protocol adapter directly but instead are connected to the gateway. Corresponding devices have to be configured so that they can be used with a gateway. See <a href="/hono/docs/admin-guide/device-registry-config/#configuring-gateway-devices">Configuring Gateway Devices</a> for details.</p>
+<p>Authenticated gateways will receive commands for devices which do not connect to a protocol adapter directly but instead are connected to the gateway. Corresponding devices have to be configured so that they can be used with a gateway. See <a href="/hono/docs/admin-guide/file-based-device-registry-config/#configuring-gateway-devices">Configuring Gateway Devices</a> for details.</p>
 
 <p>A gateway can open a link to receive commands for <em>all</em> devices it acts on behalf of. An authenticated gateway can also open a receiver link for commands targeted at a <em>specific</em> device.</p>
 
@@ -2357,6 +2464,22 @@
             
                 
                     
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
                     
                 
                 
@@ -2644,6 +2767,38 @@
             
         
                     
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
             
         
                     
@@ -3046,20 +3201,20 @@
     <div style="left: -1000px; overflow: scroll; position: absolute; top: -1000px; border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;">
       <div style="border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;"></div>
     </div>
-    <script src="/hono/docs/js/clipboard.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595208214"></script>
-    <script src="/hono/docs/js/jquery.sticky.js?1595208214"></script>
-    <script src="/hono/docs/js/featherlight.min.js?1595208214"></script>
-    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595208214"></script>
-    <script src="/hono/docs/js/highlight.pack.js?1595208214"></script>
+    <script src="/hono/docs/js/clipboard.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595294628"></script>
+    <script src="/hono/docs/js/jquery.sticky.js?1595294628"></script>
+    <script src="/hono/docs/js/featherlight.min.js?1595294628"></script>
+    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595294628"></script>
+    <script src="/hono/docs/js/highlight.pack.js?1595294628"></script>
     <script>hljs.initHighlightingOnLoad();</script>
-    <script src="/hono/docs/js/modernizr.custom.71422.js?1595208214"></script>
-    <script src="/hono/docs/js/learn.js?1595208214"></script>
-    <script src="/hono/docs/js/hugo-learn.js?1595208214"></script>
+    <script src="/hono/docs/js/modernizr.custom.71422.js?1595294628"></script>
+    <script src="/hono/docs/js/learn.js?1595294628"></script>
+    <script src="/hono/docs/js/hugo-learn.js?1595294628"></script>
 
-    <link href="/hono/docs/mermaid/mermaid.css?1595208214" type="text/css" rel="stylesheet" />
-    <script src="/hono/docs/mermaid/mermaid.js?1595208214"></script>
+    <link href="/hono/docs/mermaid/mermaid.css?1595294628" type="text/css" rel="stylesheet" />
+    <script src="/hono/docs/mermaid/mermaid.js?1595294628"></script>
     <script>
         mermaid.initialize({ startOnLoad: true });
     </script>
diff --git a/docs/user-guide/coap-adapter/index.html b/docs/user-guide/coap-adapter/index.html
index 54e9ee0..d19d4f5 100644
--- a/docs/user-guide/coap-adapter/index.html
+++ b/docs/user-guide/coap-adapter/index.html
@@ -21,19 +21,19 @@
     <title>CoAP Adapter :: Eclipse Hono&trade;</title>
 
     
-    <link href="/hono/docs/css/nucleus.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/fontawesome-all.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hybrid.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/featherlight.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/auto-complete.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/theme.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hugo-theme.css?1595208214" rel="stylesheet">
+    <link href="/hono/docs/css/nucleus.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/fontawesome-all.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hybrid.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/featherlight.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/auto-complete.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/theme.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hugo-theme.css?1595294628" rel="stylesheet">
     
-      <link href="/hono/docs/css/theme-hono.css?1595208214" rel="stylesheet">
+      <link href="/hono/docs/css/theme-hono.css?1595294628" rel="stylesheet">
     
 
-    <script src="/hono/docs/js/jquery-2.x.min.js?1595208214"></script>
+    <script src="/hono/docs/js/jquery-2.x.min.js?1595294628"></script>
 
     <style type="text/css">
       :root #header + #content > #left > #rlblock_left{
@@ -83,14 +83,14 @@
     <span data-search-clear=""><i class="fas fa-times"></i></span>
 </div>
 
-<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595208214"></script>
-<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595294628"></script>
+<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595294628"></script>
 <script type="text/javascript">
     
         var baseurl = "https:\/\/www.eclipse.org\/hono\/docs\/";
     
 </script>
-<script type="text/javascript" src="/hono/docs/js/search.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/search.js?1595294628"></script>
 
     
   </div>
@@ -315,9 +315,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/user-guide/device-registry/" title="Device Registry" class="dd-item ">
-        <a href="/hono/docs/user-guide/device-registry/">
-        Device Registry
+      <li data-nav-id="/hono/docs/user-guide/mongodb-based-device-registry/" title="MongoDB Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/mongodb-based-device-registry/">
+        MongoDB Based Device Registry
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/user-guide/file-based-device-registry/" title="File Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/file-based-device-registry/">
+        File Based Device Registry
         
         </a>
     </li>
@@ -537,9 +556,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/device-registry-config/" title="Device Registry Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/device-registry-config/">
-        Device Registry Configuration
+      <li data-nav-id="/hono/docs/admin-guide/mongodb-device-registry-config/" title="MongoDB Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mongodb-device-registry-config/">
+        MongoDB Based Device Registry Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/admin-guide/file-based-device-registry-config/" title="File Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/file-based-device-registry-config/">
+        File Based Device Registry Configuration
         
         </a>
     </li>
@@ -594,6 +632,25 @@
  
   
     
+      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
+        MQTT Adapter Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
       <li data-nav-id="/hono/docs/admin-guide/amqp-adapter-config/" title="AMQP Adapter Configuration" class="dd-item ">
         <a href="/hono/docs/admin-guide/amqp-adapter-config/">
         AMQP Adapter Configuration
@@ -613,9 +670,9 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
-        MQTT Adapter Configuration
+      <li data-nav-id="/hono/docs/admin-guide/coap-adapter-config/" title="CoAP Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/coap-adapter-config/">
+        CoAP Adapter Configuration
         
         </a>
     </li>
@@ -1277,7 +1334,27 @@
                   
                     
                     
-                      <option id="stable" value="/hono/docs/user-guide/coap-adapter/" selected>stable (1.2)</option>
+                      <option id="stable" value="/hono/docs/user-guide/coap-adapter/" selected>stable (1.3)</option>
+                    
+                  
+              
+                  
+              
+                  
+              
+                  
+              
+                  
+              
+          
+              
+              
+                  
+              
+                  
+                    
+                    
+                      <option id="1.2" value="/hono/docs/1.2/user-guide/coap-adapter/">1.2</option>
                     
                   
               
@@ -1297,6 +1374,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="dev" value="/hono/docs/dev/user-guide/coap-adapter/">dev</option>
@@ -1491,8 +1570,14 @@
 
 <h2 id="message-limits">Message Limits</h2>
 
-<p>Before accepting any telemetry or event or command messages, the CoAP adapter verifies that the configured <a href="/hono/docs/concepts/resource-limits/#messages-limit">message limit</a> is not exceeded.
-For CoAP currently only the messages limit is verified, the connections limit is not available. If the limit is exceeded then the incoming message is discarded with the status code <code>429 Too Many Requests</code>.</p>
+<p>The adapter rejects</p>
+
+<ul>
+<li>a client&rsquo;s request to upload data with status code <code>429 Too Many Requests</code> and</li>
+<li>any AMQP 1.0 message containing a command sent by a north bound application</li>
+</ul>
+
+<p>if the <a href="/hono/docs/concepts/resource-limits/">message limit</a> that has been configured for the device&rsquo;s tenant is exceeded.</p>
 
 <h2 id="coap-content-format-codes">CoAP Content Format Codes</h2>
 
@@ -2130,7 +2215,7 @@
 
 <h3 id="commands-handled-by-gateways">Commands handled by gateways</h3>
 
-<p>Authenticated gateways will receive commands for devices which do not connect to a protocol adapter directly but instead are connected to the gateway. Corresponding devices have to be configured so that they can be used with a gateway. See <a href="/hono/docs/admin-guide/device-registry-config/#configuring-gateway-devices">Configuring Gateway Devices</a> for details.</p>
+<p>Authenticated gateways will receive commands for devices which do not connect to a protocol adapter directly but instead are connected to the gateway. Corresponding devices have to be configured so that they can be used with a gateway. See <a href="/hono/docs/admin-guide/file-based-device-registry-config/#configuring-gateway-devices">Configuring Gateway Devices</a> for details.</p>
 
 <p>A gateway can send a request with the <code>hono-ttd</code> query parameter on the <code>/event</code> or <code>/telemetry</code> URI, indicating its readiness to receive a command for <em>any</em> device it acts on behalf of. Note that in this case, the business application will be notified with the gateway id in the <code>device_id</code> property of the downstream message.</p>
 
@@ -2683,6 +2768,22 @@
             
                 
                     
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
                     
                 
                 
@@ -2954,6 +3055,38 @@
             
         
                     
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
             
         
                     
@@ -3356,20 +3489,20 @@
     <div style="left: -1000px; overflow: scroll; position: absolute; top: -1000px; border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;">
       <div style="border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;"></div>
     </div>
-    <script src="/hono/docs/js/clipboard.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595208214"></script>
-    <script src="/hono/docs/js/jquery.sticky.js?1595208214"></script>
-    <script src="/hono/docs/js/featherlight.min.js?1595208214"></script>
-    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595208214"></script>
-    <script src="/hono/docs/js/highlight.pack.js?1595208214"></script>
+    <script src="/hono/docs/js/clipboard.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595294628"></script>
+    <script src="/hono/docs/js/jquery.sticky.js?1595294628"></script>
+    <script src="/hono/docs/js/featherlight.min.js?1595294628"></script>
+    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595294628"></script>
+    <script src="/hono/docs/js/highlight.pack.js?1595294628"></script>
     <script>hljs.initHighlightingOnLoad();</script>
-    <script src="/hono/docs/js/modernizr.custom.71422.js?1595208214"></script>
-    <script src="/hono/docs/js/learn.js?1595208214"></script>
-    <script src="/hono/docs/js/hugo-learn.js?1595208214"></script>
+    <script src="/hono/docs/js/modernizr.custom.71422.js?1595294628"></script>
+    <script src="/hono/docs/js/learn.js?1595294628"></script>
+    <script src="/hono/docs/js/hugo-learn.js?1595294628"></script>
 
-    <link href="/hono/docs/mermaid/mermaid.css?1595208214" type="text/css" rel="stylesheet" />
-    <script src="/hono/docs/mermaid/mermaid.js?1595208214"></script>
+    <link href="/hono/docs/mermaid/mermaid.css?1595294628" type="text/css" rel="stylesheet" />
+    <script src="/hono/docs/mermaid/mermaid.js?1595294628"></script>
     <script>
         mermaid.initialize({ startOnLoad: true });
     </script>
diff --git a/docs/user-guide/device-registry/index.html b/docs/user-guide/file-based-device-registry/index.html
similarity index 65%
rename from docs/user-guide/device-registry/index.html
rename to docs/user-guide/file-based-device-registry/index.html
index 5ff6a71..ba73e0a 100644
--- a/docs/user-guide/device-registry/index.html
+++ b/docs/user-guide/file-based-device-registry/index.html
@@ -18,22 +18,22 @@
 <meta name="msapplication-config" content="/hono/docs/favicon/browserconfig.xml">
 <meta name="theme-color" content="#ffffff">
 
-    <title>Device Registry :: Eclipse Hono&trade;</title>
+    <title>File Based Device Registry :: Eclipse Hono&trade;</title>
 
     
-    <link href="/hono/docs/css/nucleus.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/fontawesome-all.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hybrid.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/featherlight.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/auto-complete.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/theme.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hugo-theme.css?1595208214" rel="stylesheet">
+    <link href="/hono/docs/css/nucleus.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/fontawesome-all.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hybrid.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/featherlight.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/auto-complete.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/theme.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hugo-theme.css?1595294628" rel="stylesheet">
     
-      <link href="/hono/docs/css/theme-hono.css?1595208214" rel="stylesheet">
+      <link href="/hono/docs/css/theme-hono.css?1595294628" rel="stylesheet">
     
 
-    <script src="/hono/docs/js/jquery-2.x.min.js?1595208214"></script>
+    <script src="/hono/docs/js/jquery-2.x.min.js?1595294628"></script>
 
     <style type="text/css">
       :root #header + #content > #left > #rlblock_left{
@@ -53,18 +53,18 @@
 
 <meta name="twitter:card" content="summary_large_image">
 <meta name="twitter:site" content="@EclipseHono">
-<meta name="twitter:title" content="Device Registry :: Eclipse Hono&amp;trade;">
+<meta name="twitter:title" content="File Based Device Registry :: Eclipse Hono&amp;trade;">
 <meta name="twitter:image" content="https://www.eclipse.org/hono/docs/images/twitter_image.png">
 <meta name="twitter:description" content="A set of micro-services for connecting millions of devices.">
 
 
-<meta property="og:title" content="Device Registry :: Eclipse Hono&amp;trade;" />
+<meta property="og:title" content="File Based Device Registry :: Eclipse Hono&amp;trade;" />
 <meta property="og:type" content="website" />
-<meta property="og:url" content="https://www.eclipse.org/hono/docs/user-guide/device-registry//" />
+<meta property="og:url" content="https://www.eclipse.org/hono/docs/user-guide/file-based-device-registry//" />
 <meta property="og:image" content="https://www.eclipse.org/hono/docs/images/twitter_image.png" />
 
   </head>
-  <body class="" data-url="/hono/docs/user-guide/device-registry/">
+  <body class="" data-url="/hono/docs/user-guide/file-based-device-registry/">
     <nav id="sidebar" class="">
 
 
@@ -83,14 +83,14 @@
     <span data-search-clear=""><i class="fas fa-times"></i></span>
 </div>
 
-<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595208214"></script>
-<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595294628"></script>
+<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595294628"></script>
 <script type="text/javascript">
     
         var baseurl = "https:\/\/www.eclipse.org\/hono\/docs\/";
     
 </script>
-<script type="text/javascript" src="/hono/docs/js/search.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/search.js?1595294628"></script>
 
     
   </div>
@@ -315,9 +315,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/user-guide/device-registry/" title="Device Registry" class="dd-item active">
-        <a href="/hono/docs/user-guide/device-registry/">
-        Device Registry
+      <li data-nav-id="/hono/docs/user-guide/mongodb-based-device-registry/" title="MongoDB Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/mongodb-based-device-registry/">
+        MongoDB Based Device Registry
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/user-guide/file-based-device-registry/" title="File Based Device Registry" class="dd-item active">
+        <a href="/hono/docs/user-guide/file-based-device-registry/">
+        File Based Device Registry
         
         </a>
     </li>
@@ -537,9 +556,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/device-registry-config/" title="Device Registry Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/device-registry-config/">
-        Device Registry Configuration
+      <li data-nav-id="/hono/docs/admin-guide/mongodb-device-registry-config/" title="MongoDB Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mongodb-device-registry-config/">
+        MongoDB Based Device Registry Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/admin-guide/file-based-device-registry-config/" title="File Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/file-based-device-registry-config/">
+        File Based Device Registry Configuration
         
         </a>
     </li>
@@ -594,6 +632,25 @@
  
   
     
+      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
+        MQTT Adapter Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
       <li data-nav-id="/hono/docs/admin-guide/amqp-adapter-config/" title="AMQP Adapter Configuration" class="dd-item ">
         <a href="/hono/docs/admin-guide/amqp-adapter-config/">
         AMQP Adapter Configuration
@@ -613,9 +670,9 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
-        MQTT Adapter Configuration
+      <li data-nav-id="/hono/docs/admin-guide/coap-adapter-config/" title="CoAP Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/coap-adapter-config/">
+        CoAP Adapter Configuration
         
         </a>
     </li>
@@ -1277,7 +1334,7 @@
                   
                     
                     
-                      <option id="stable" value="/hono/docs/user-guide/device-registry/" selected>stable (1.2)</option>
+                      <option id="stable" value="/hono/docs/user-guide/file-based-device-registry/" selected>stable (1.3)</option>
                     
                   
               
@@ -1287,24 +1344,14 @@
               
                   
               
+                  
+              
           
               
               
                   
               
                   
-                    
-                    
-                      <option id="1.1" value="/hono/docs/1.1/user-guide/device-registry/">1.1</option>
-                    
-                  
-              
-                  
-              
-                  
-              
-          
-              
               
                   
               
@@ -1313,12 +1360,10 @@
                   
                     
                     
-                      <option id="1.0" value="/hono/docs/1.0/user-guide/device-registry/">1.0</option>
+                      <option id="dev" value="/hono/docs/dev/user-guide/file-based-device-registry/">dev</option>
                     
                   
               
-                  
-              
           
         </select>
         <svg version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
@@ -1381,7 +1426,7 @@
                   
                   
                   <div id="top-github-link">
-                    <a class="github-link" title='Edit this page' href="https://github.com/eclipse/hono/edit/master/site/documentation/content/user-guide/device-registry.md" target="blank">
+                    <a class="github-link" title='Edit this page' href="https://github.com/eclipse/hono/edit/master/site/documentation/content/user-guide/file-based-device-registry.md" target="blank">
                       <i class="fas fa-code-branch"></i>
                       <span id="top-github-link-text">Edit this page</span>
                     </a>
@@ -1412,7 +1457,7 @@
             
           
           
-            <a href='/hono/docs/'>Documentation</a> > <a href='/hono/docs/user-guide/'>User Guide</a> > Device Registry
+            <a href='/hono/docs/'>Documentation</a> > <a href='/hono/docs/user-guide/'>User Guide</a> > File Based Device Registry
           
          
           
@@ -1429,25 +1474,9 @@
 <ul>
 <li>
 <ul>
-<li><a href="#managing-tenants">Managing Tenants</a>
-<ul>
-<li><a href="#add-a-tenant">Add a Tenant</a></li>
-<li><a href="#get-configuration-details-of-a-tenant">Get configuration details of a Tenant</a></li>
-<li><a href="#update-tenant">Update Tenant</a></li>
-<li><a href="#delete-tenant">Delete Tenant</a></li>
-</ul></li>
-<li><a href="#managing-device-registration-information">Managing Device Registration Information</a>
-<ul>
-<li><a href="#register-device">Register Device</a></li>
-<li><a href="#read-device">Read Device</a></li>
-<li><a href="#update-device">Update Device</a></li>
-<li><a href="#delete-device">Delete Device</a></li>
-</ul></li>
-<li><a href="#managing-credentials">Managing Credentials</a>
-<ul>
-<li><a href="#update-credentials-for-a-device">Update Credentials for a Device</a></li>
-<li><a href="#get-all-credentials-for-a-device">Get all Credentials for a Device</a></li>
-</ul></li>
+<li><a href="#managing-tenants">Managing Tenants</a></li>
+<li><a href="#managing-devices">Managing Devices</a></li>
+<li><a href="#managing-credentials">Managing Credentials</a></li>
 </ul></li>
 </ul>
 </nav>
@@ -1462,7 +1491,7 @@
         
         <div id="body-inner">
           
-            <h1>Device Registry</h1>
+            <h1>File Based Device Registry</h1>
           
 
         
@@ -1485,518 +1514,15 @@
 
 <h2 id="managing-tenants">Managing Tenants</h2>
 
-<p>The following sections describe the resources representing the operations of the Tenant API and how they can be used to manage tenants.
-Please refer to the <a href="/hono/docs/api/management/">Device Registry HTTP API</a> for the specific elements that are explained in detail there.</p>
+<p>Please refer to the <a href="/hono/docs/api/management/#tenants">Device Registry Management API</a> for information about managing tenants.</p>
 
-<h3 id="add-a-tenant">Add a Tenant</h3>
+<h2 id="managing-devices">Managing Devices</h2>
 
-<ul>
-<li>URI: <code>/v1/tenants/${tenantId}</code></li>
-<li>Method: <code>POST</code></li>
-<li>Request Headers:
-
-<ul>
-<li>(required) <code>Content-Type</code>: <code>application/json</code> (no other type supported)</li>
-</ul></li>
-<li>Request Body:
-
-<ul>
-<li>(Optional) A JSON object as specified by <a href="/hono/docs/api/management/">Tenant schema</a> of the HTTP API specification.</li>
-</ul></li>
-<li>Status Codes:
-
-<ul>
-<li>201 (Created): Tenant has been added successfully under the resource indicated by <code>Location</code> header.</li>
-<li>400 (Bad Request): The tenant has not been created because the request was malformed, e .g. because the payload was malformed. The response body may contain hints regarding the cause of the problem.</li>
-<li>409 (Conflict): A tenant with the given <code>tenantId</code> already exists. The request has not been processed.</li>
-</ul></li>
-<li>Response Headers:
-
-<ul>
-<li><code>Location</code>: The URI under which the newly created resource can be accessed.</li>
-<li><code>ETag</code>: Version of the resource</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<p>The following commands add some tenants with different adapter configurations:</p>
-
-<p>Add a tenant that has all adapters set to enabled:</p>
-
-<pre><code class="language-sh">curl -i -X POST http://localhost:28080/v1/tenants/tenantAllAdapters
-
-HTTP/1.1 201 Created
-ETag: becc93d7-ab0f-48ec-ad26-debdf339cbf4
-Location: /v1/tenants/tenantAllAdapters
-Content-Type: application/json; charset=utf-8
-
-{&quot;id&quot;: &quot;tenantAllAdapters&quot;}
-</code></pre>
-
-<p>Add a tenant that can only use the MQTT adapter:</p>
-
-<pre><code class="language-sh">curl -i -X POST -H 'Content-Type: application/json' --data-binary '{
-    &quot;adapters&quot;: [ {
-        &quot;type&quot;: &quot;hono-mqtt&quot;,
-        &quot;enabled&quot;: true
-        } ]
-  }' http://localhost:28080/v1/tenants/tenantMqttAdapter
-
-HTTP/1.1 201 Created
-ETag: becc93d7-ab0f-48ec-ad26-debdf339cbf4
-Location:  /v1/tenants/tenantMqttAdapter
-Content-Type: application/json; charset=utf-8
-
-{&quot;id&quot;: &quot;tenantMqttAdapter&quot;}
-</code></pre>
-
-<h3 id="get-configuration-details-of-a-tenant">Get configuration details of a Tenant</h3>
-
-<ul>
-<li>URI: <code>/v1/tenants/${tenantId}</code></li>
-<li>Method: <code>GET</code></li>
-<li>Status Codes:
-
-<ul>
-<li>200 (OK): A tenant with the given identifier has been found. The response body contains the tenant data as specified by <a href="/hono/docs/api/management/">Tenant schema</a> of the HTTP API specification.</li>
-<li>404 (Not Found): No tenant with the given identifier is registered.</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<p>The following command retrieves the details for the tenant <code>tenantMqttAdapter</code>:</p>
-
-<pre><code class="language-sh">curl -i http://localhost:28080/v1/tenants/tenantMqttAdapter
-
-HTTP/1.1 200 OK
-ETag: becc93d7-ab0f-48ec-ad26-debdf339cbf4
-Content-Type: application/json; charset=utf-8
-
-{
-     &quot;enabled&quot;: true,
-     &quot;adapters&quot;: [ {
-         &quot;type&quot;: &quot;hono-mqtt&quot;,
-         &quot;enabled&quot;: true
-     } ]
-}
-</code></pre>
-
-<p><strong>NB</strong> A tenant can be created without specifying a tenant identifier. The device registry will generate a tenant ID:</p>
-
-<pre><code class="language-sh">curl -i  -X POST http://localhost:28080/v1/tenants/
-
-HTTP/1.1 201 Created
-Etag: edc93899-7838-4dd1-93c8-839748c2fa42
-location: /v1/tenants/0b2df55f-1a02-43f7-a1c0-f3dbd25041e0
-content-type: application/json; charset=utf-8
-content-length: 45
-
-{&quot;id&quot;:&quot;0b2df55f-1a02-43f7-a1c0-f3dbd25041e0&quot;}
-</code></pre>
-
-<h3 id="update-tenant">Update Tenant</h3>
-
-<ul>
-<li>URI: <code>/v1/tenants/${tenantId}</code></li>
-<li>Method: <code>PUT</code></li>
-<li>Request Headers:
-
-<ul>
-<li>(required) <code>Content-Type</code>: <code>application/json</code> (no other type supported)</li>
-</ul></li>
-<li>Request Body:
-
-<ul>
-<li>(required) A JSON object as specified by <a href="/hono/docs/api/management/">Tenant schema</a> of the HTTP API specification.</li>
-</ul></li>
-<li>Status Codes:
-
-<ul>
-<li>204 (No Content): The tenant has been updated successfully.</li>
-<li>400 (Bad Request): The tenant has not been updated because the request was malformed, e .g. because the payload was malformed. The response body may contain hints regarding the cause of the problem.</li>
-<li>404 (Not Found): The request could not be processed because no tenant with the given identifier exists.</li>
-</ul></li>
-</ul>
-
-<p>This resource can be used to change the configuration of a particular tenant.</p>
-
-<p><strong>Example</strong></p>
-
-<p>The following command disables the MQTT adapter for devices that belong to the tenant <code>tenantMqttAdapter</code>:</p>
-
-<pre><code class="language-sh">curl -i -X PUT -H 'Content-Type: application/json' --data-binary '{
-      &quot;adapters&quot;: [ {
-          &quot;type&quot;: &quot;hono-mqtt&quot;,
-          &quot;enabled&quot;: true
-          } ]
-  }' http://localhost:28080/v1/tenants/tenantMqttAdapter
-
-HTTP/1.1 204 No Content
-ETag: 8919c736-30aa-40ce-a45a-830b90c4cd42
-Content-Length: 0
-</code></pre>
-
-<h3 id="delete-tenant">Delete Tenant</h3>
-
-<ul>
-<li>URI: <code>/v1/tenants/${tenantId}</code></li>
-<li>Method: <code>DELETE</code></li>
-<li>Status Codes:
-
-<ul>
-<li>204 (No Content): The tenant with the given identifier has been deleted.</li>
-<li>404 (Not Found): The request could not be processed because no tenant with the given identifier exists.</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<pre><code class="language-sh">curl -i -X DELETE http://localhost:28080/v1/tenants/tenantMqttAdapter
-
-HTTP/1.1 204 No Content
-Content-Length: 0
-</code></pre>
-
-<h2 id="managing-device-registration-information">Managing Device Registration Information</h2>
-
-<p>The following sections describe the resources representing the operations of the <a href="/hono/docs/api/device-registration/">Device Registration API</a> and how they can be used to manage device registration information.
-Please refer to the <a href="/hono/docs/api/management/">Device Registry HTTP API</a> for the specific elements that are explained in detail there.</p>
-
-<h3 id="register-device">Register Device</h3>
-
-<ul>
-<li>URI: <code>/v1/devices/${tenantId}/${deviceId}</code></li>
-<li>Method: <code>POST</code></li>
-<li>Headers:
-
-<ul>
-<li>(required) <code>Content-Type</code>: <code>application/json</code></li>
-</ul></li>
-<li>Request Body:
-
-<ul>
-<li>(Optional) A JSON object as specified by <a href="/hono/docs/api/management/">Device schema</a> of the HTTP API specification.</li>
-</ul></li>
-<li>Status Codes:
-
-<ul>
-<li>201 (Created): Device has been registered successfully under resource indicated by <code>Location</code> header.</li>
-<li>400 (Bad Request): Device has not been registered because the request was malformed, e .g. a required header is missing (the body may contain hints regarding the problem).</li>
-<li>409 (Conflict): There already exists a device with the given ID. The request has not been processed.</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<p>The following command registers a device with ID <code>4711</code> for tenant <code>DEFAULT_TENANT</code></p>
-
-<pre><code class="language-sh">curl -i -X POST -H 'Content-Type: application/json' --data-binary '{
-    &quot;ext&quot;: {
-        &quot;ep&quot;: &quot;IMEI4711&quot;
-    }
-}' http://localhost:28080/v1/devices/DEFAULT_TENANT/4711
-</code></pre>
-
-<p>The response will contain a <code>Location</code> header containing the resource path created for the device. In this example it will look
-like this:</p>
-
-<pre><code class="language-sh">HTTP/1.1 201 Created
-Location: /v1/devices/DEFAULT_TENANT/4711
-ETag: becc93d7-ab0f-48ec-ad26-debdf339cbf4
-Content-Type: application/json; charset=utf-8
-
-{&quot;id&quot;: &quot;4711&quot;}
-</code></pre>
-
-<p><strong>NB</strong> A device can be created without specifying a device identifier. The device registry will generate a device identifier:</p>
-
-<pre><code class="language-sh">curl -i -X POST http://localhost:28080/v1/devices/DEFAULT_TENANT
-
-HTTP/1.1 201 Created
-Etag: 0d615bcd-0825-44d9-9ef5-54a7b12165d8
-location: /v1/devices/DEFAULT_TENANT/98d25103-d49d-44b0-bdd0-0de84743c522
-content-type: application/json; charset=utf-8
-content-length: 45
-
-{&quot;id&quot;:&quot;98d25103-d49d-44b0-bdd0-0de84743c522&quot;}
-</code></pre>
-
-<h3 id="read-device">Read Device</h3>
-
-<ul>
-<li>URI: <code>/v1/devices/${tenantId}/${deviceId}</code></li>
-<li>Method: <code>GET</code></li>
-<li>Status Codes:
-
-<ul>
-<li>200 (OK): A device with the given identifier has been found. The response body contains the registration information as specified by <a href="/hono/docs/api/management/">Device schema</a> of the HTTP API specification.</li>
-<li>404 (Not Found): No device with the given identifier is registered for the given tenant.</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<p>The following command retrieves registration data for device <code>4711</code>:</p>
-
-<pre><code class="language-sh">curl -i http://localhost:28080/v1/devices/DEFAULT_TENANT/4711
-
-HTTP/1.1 200 OK
-Content-Type: application/json; charset=utf-8
-
-{
-    &quot;enabled&quot;: true,
-    &quot;ext&quot;: {
-        &quot;ep&quot;: &quot;IMEI4711&quot;
-    }
-}
-</code></pre>
-
-<h3 id="update-device">Update Device</h3>
-
-<ul>
-<li>URI: <code>/devices/v1/${tenantId}/${deviceId}</code></li>
-<li>Method: <code>PUT</code></li>
-<li>Headers:
-
-<ul>
-<li>(required) <code>Content-Type</code>: <code>application/json</code></li>
-</ul></li>
-<li>Parameters (encoded as a JSON object in the request body):</li>
-<li>Request Body:
-
-<ul>
-<li>(required) A JSON object as specified by <a href="/hono/docs/api/management/">Device schema</a> of the HTTP API specification. All existing registration information will be replaced by the data provided in the object.</li>
-</ul></li>
-<li>Status Codes:
-
-<ul>
-<li>204 (No Content): Device registration data has been updated.</li>
-<li>400 (Bad Request): Device registration has not been updated because the request was malformed, e .g. a required header is missing (the body may contain hints regarding the problem).</li>
-<li>404 (Not Found): No device with the given identifier is registered for the given tenant.</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<pre><code class="language-sh">curl -i -X PUT -H 'Content-Type: application/json' --data-binary '{
-    &quot;ext&quot;: {
-        &quot;ep&quot;: &quot;IMEI4711&quot;,
-        &quot;psk-id&quot;: &quot;psk4711&quot;
-    }
-}' http://localhost:28080/v1/devices/DEFAULT_TENANT/4711
-
-HTTP/1.1 204 No Content
-Content-Length: 0
-</code></pre>
-
-<h3 id="delete-device">Delete Device</h3>
-
-<ul>
-<li>URI: <code>/v1/devices/${tenantId}/${deviceId}</code></li>
-<li>Method: <code>DELETE</code></li>
-<li>Status Codes:
-
-<ul>
-<li>204 (No Content): Device registration has been deleted.</li>
-<li>404 (Not Found): No device with the given identifier is registered for the given tenant.</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<pre><code class="language-sh">curl -i -X DELETE http://localhost:28080/v1/devices/DEFAULT_TENANT/4711
-
-HTTP/1.1 204 No Content
-Content-Length: 0
-</code></pre>
+<p>Please refer to the <a href="/hono/docs/api/management/#devices">Device Registry Management API</a> for information about managing devices.</p>
 
 <h2 id="managing-credentials">Managing Credentials</h2>
 
-<p>The following sections describe the resources representing the operations of the Credentials API and how they can be used to manage credentials for devices.
-Please refer to the <a href="/hono/docs/api/management/">Device Registry HTTP API</a> for the specific elements that are explained in detail there.</p>
-
-<h3 id="update-credentials-for-a-device">Update Credentials for a Device</h3>
-
-<ul>
-<li>URI: <code>/v1/credentials/${tenantId}/${deviceId}</code></li>
-<li>Method: <code>PUT</code></li>
-<li>Request Headers:
-
-<ul>
-<li>(required) <code>Content-Type</code>: <code>application/json</code> (no other type supported)</li>
-</ul></li>
-<li>Request Body:
-
-<ul>
-<li>(required) A JSON object as specified by <a href="/hono/docs/api/management/">Credentials schema</a> of the HTTP API specification.</li>
-</ul></li>
-<li>Status Codes:
-
-<ul>
-<li>204 (No Content): Credentials have been updated successfully.</li>
-<li>400 (Bad Request): The credentials have not been added because the request was malformed, e .g. because the payload did not contain required values. The response body may contain hints regarding the cause of the problem.</li>
-</ul></li>
-<li>Response Headers:
-
-<ul>
-<li><code>ETag</code>: Version of the resource</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<p>The following command adds some <code>hashed-password</code> credentials from a given plain text password for device <code>4710</code> using authentication identifier <code>sensor10</code>:</p>
-
-<pre><code class="language-sh">curl -i -X PUT -H 'Content-Type: application/json' --data-binary '[{
-  &quot;type&quot;: &quot;hashed-password&quot;,
-  &quot;auth-id&quot;: &quot;sensor10&quot;,
-  &quot;secrets&quot;: [{
-      &quot;pwd-plain&quot;: &quot;mylittlesecret&quot;
-  }]
-}]' http://localhost:28080/v1/credentials/DEFAULT_TENANT/4710
-  
-HTTP/1.1 204 No Content
-ETag: becc93d7-ab0f-48ec-ad26-debdf339cbf4x
-</code></pre>
-
-<p>This uses a convenient option which lets the Device Registry do the hashing of the password. The following command retrieves the credentials that are stored by the Device Registry as a result of the command above:</p>
-
-<pre><code class="language-sh">curl -i http://localhost:28080/v1/credentials/DEFAULT_TENANT/4710
-
-HTTP/1.1 200 OK
-Content-Type: application/json; charset=utf-8
-ETag: becc93d7-ab0f-48ec-ad26-debdf339cbf4x
-
-[{
-  &quot;type&quot;: &quot;hashed-password&quot;,
-  &quot;auth-id&quot;: &quot;sensor10&quot;,
-  &quot;enabled&quot;: true,
-  &quot;secrets&quot;: [
-    {
-      &quot;id&quot;: &quot;349556ea-4902-47c7-beb0-1009ab693fb4&quot;
-    }
-  ]
-}]
-</code></pre>
-
-<p>The above result does not contain <code>pwd_hash</code> and <code>hash_function</code> of the secret, as these values are confidential.</p>
-
-<p>The following commands set some <code>hashed-password</code> credentials for device <code>4720</code> using authentication identifier <code>sensor20</code>:</p>
-
-<pre><code class="language-sh">curl -i -X PUT -H 'Content-Type: application/json' --data-binary '[{
-    &quot;type&quot;: &quot;hashed-password&quot;,
-    &quot;auth-id&quot;: &quot;sensor20&quot;,
-    &quot;secrets&quot;: [{
-        &quot;pwd-plain&quot;: &quot;mylittlesecret&quot;
-    }]
-  }]' http://localhost:28080/v1/credentials/DEFAULT_TENANT/4720
-
-HTTP/1.1 204 No Content
-ETag: 02c99fb5-af8c-409f-8520-b405e224b27f
-</code></pre>
-
-<p>The following command adds an expiration date to the <code>hashed-password</code> credentials for authentication identifier <code>sensor20</code>:</p>
-
-<pre><code class="language-sh">curl -i -X PUT -H 'Content-Type: application/json' --data-binary '{
-    &quot;device-id&quot;: &quot;4720&quot;,
-    &quot;type&quot;: &quot;hashed-password&quot;,
-    &quot;auth-id&quot;: &quot;sensor20&quot;,
-    &quot;secrets&quot;: [{
-        &quot;pwd-plain&quot;: &quot;mylittlesecret&quot;,
-        &quot;not-after&quot;: &quot;2018-01-01T00:00:00+01:00&quot;
-    }]
-}' http://localhost:28080/v1/credentials/DEFAULT_TENANT/4720
-
-HTTP/1.1 204 No Content
-ETag: becc93d7-ab0f-48ec-ad26-debdf339cbf4x
-</code></pre>
-
-<p>Multiple credentials of different type can be registered for the same authentication identifier.
-The following commands add <code>psk</code> credentials for the same device <code>4720</code> using authentication identifier <code>sensor20</code>:</p>
-
-<pre><code class="language-sh">SHARED_KEY=$(echo -n &quot;TheSharedKey&quot; | base64 -w 0)
-curl -i -X PUT -H 'Content-Type: application/json' --data-binary '[
-{
-    &quot;type&quot;: &quot;hashed-password&quot;,
-    &quot;auth-id&quot;: &quot;sensor20&quot;,
-    &quot;secrets&quot;: [{
-        &quot;pwd-plain&quot;: &quot;mylittlesecret&quot;
-    }]
-},
-{
-   &quot;device-id&quot;: &quot;4720&quot;,
-   &quot;type&quot;: &quot;psk&quot;,
-   &quot;auth-id&quot;: &quot;sensor20&quot;,
-   &quot;secrets&quot;: [{
-     &quot;key&quot;: &quot;'$SHARED_KEY'&quot;
-     }]
-  }]' http://localhost:28080/v1/credentials/DEFAULT_TENANT/4720
-
-HTTP/1.1 204 No Content
-ETag: 122c971a-505a-4336-8f7d-640360e909bc
-</code></pre>
-
-<p>The following command deletes all credentials for device <code>4710</code>:</p>
-
-<pre><code class="language-sh">curl -i -X PUT -H 'Content-Type: application/json' --data-binary '[]' http://localhost:28080/v1/credentials/DEFAULT_TENANT/4710
-
-HTTP/1.1 204 No Content
-ETag: d383ba4d-1853-4d03-b322-b7ff5af05ae2
-</code></pre>
-
-<h3 id="get-all-credentials-for-a-device">Get all Credentials for a Device</h3>
-
-<ul>
-<li>URI: <code>/v1/credentials/${tenantId}/${deviceId}</code></li>
-<li>Method: <code>GET</code></li>
-<li>Status Codes:
-
-<ul>
-<li>200 (OK): Credentials for the device have been found, body contains the credentials. The response body contains the registration information as specified by <a href="/hono/docs/api/management/">Credentials schema</a> of the HTTP API specification.</li>
-<li>404 (Not Found): No credentials for the device are registered.</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<p>The following command retrieves credentials metadata for device <code>4720</code>:</p>
-
-<pre><code class="language-sh">curl -i http://localhost:28080/v1/credentials/DEFAULT_TENANT/4720
-
-HTTP/1.1 200 OK
-Content-Type: application/json; charset=utf-8
-ETag: f3449b77-2c84-4b09-8d04-2b305876e0cb
-
-{[
-    {
-        &quot;auth-id&quot;: &quot;sensor20&quot;,
-        &quot;enabled&quot;: true,
-        &quot;secrets&quot;: [
-            {
-                &quot;id&quot;: &quot;d383ba4d-1853-4d03-b322-b7ff5af05ae2&quot;
-                &quot;not-after&quot;: &quot;2020-02-1T00:00:00+01:00&quot;
-            },
-            {
-                &quot;id&quot;: &quot;46810d5c-133e-4c1c-994d-ed7745516b8e&quot;
-                &quot;not-before&quot;: &quot;2020-01-01T00:00:00+01:00&quot;
-            }
-        ],
-        &quot;type&quot;: &quot;hashed-password&quot;
-    },
-    {
-        &quot;auth-id&quot;: &quot;sensor20&quot;,
-        &quot;enabled&quot;: true,
-        &quot;secrets&quot;: [
-            {
-                &quot;key&quot;: &quot;VGhlU2hhcmVkS2V5&quot;
-            }
-        ],
-        &quot;type&quot;: &quot;psk&quot;
-    }
-]}
-</code></pre>
+<p>Please refer to the <a href="/hono/docs/api/management/#credentials">Device Registry Management API</a> for information about managing credentials.</p>
 
 <footer class=" footline" >
 	
@@ -2195,6 +1721,25 @@
             
                 
                     
+                        
+                        
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
                     
                 
                 
@@ -2530,6 +2075,38 @@
             
         
                     
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
             
         
                     
@@ -2932,20 +2509,20 @@
     <div style="left: -1000px; overflow: scroll; position: absolute; top: -1000px; border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;">
       <div style="border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;"></div>
     </div>
-    <script src="/hono/docs/js/clipboard.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595208214"></script>
-    <script src="/hono/docs/js/jquery.sticky.js?1595208214"></script>
-    <script src="/hono/docs/js/featherlight.min.js?1595208214"></script>
-    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595208214"></script>
-    <script src="/hono/docs/js/highlight.pack.js?1595208214"></script>
+    <script src="/hono/docs/js/clipboard.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595294628"></script>
+    <script src="/hono/docs/js/jquery.sticky.js?1595294628"></script>
+    <script src="/hono/docs/js/featherlight.min.js?1595294628"></script>
+    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595294628"></script>
+    <script src="/hono/docs/js/highlight.pack.js?1595294628"></script>
     <script>hljs.initHighlightingOnLoad();</script>
-    <script src="/hono/docs/js/modernizr.custom.71422.js?1595208214"></script>
-    <script src="/hono/docs/js/learn.js?1595208214"></script>
-    <script src="/hono/docs/js/hugo-learn.js?1595208214"></script>
+    <script src="/hono/docs/js/modernizr.custom.71422.js?1595294628"></script>
+    <script src="/hono/docs/js/learn.js?1595294628"></script>
+    <script src="/hono/docs/js/hugo-learn.js?1595294628"></script>
 
-    <link href="/hono/docs/mermaid/mermaid.css?1595208214" type="text/css" rel="stylesheet" />
-    <script src="/hono/docs/mermaid/mermaid.js?1595208214"></script>
+    <link href="/hono/docs/mermaid/mermaid.css?1595294628" type="text/css" rel="stylesheet" />
+    <script src="/hono/docs/mermaid/mermaid.js?1595294628"></script>
     <script>
         mermaid.initialize({ startOnLoad: true });
     </script>
diff --git a/docs/user-guide/http-adapter/index.html b/docs/user-guide/http-adapter/index.html
index d176283..c8ef0e0 100644
--- a/docs/user-guide/http-adapter/index.html
+++ b/docs/user-guide/http-adapter/index.html
@@ -21,19 +21,19 @@
     <title>HTTP Adapter :: Eclipse Hono&trade;</title>
 
     
-    <link href="/hono/docs/css/nucleus.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/fontawesome-all.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hybrid.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/featherlight.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/auto-complete.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/theme.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hugo-theme.css?1595208214" rel="stylesheet">
+    <link href="/hono/docs/css/nucleus.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/fontawesome-all.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hybrid.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/featherlight.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/auto-complete.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/theme.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hugo-theme.css?1595294628" rel="stylesheet">
     
-      <link href="/hono/docs/css/theme-hono.css?1595208214" rel="stylesheet">
+      <link href="/hono/docs/css/theme-hono.css?1595294628" rel="stylesheet">
     
 
-    <script src="/hono/docs/js/jquery-2.x.min.js?1595208214"></script>
+    <script src="/hono/docs/js/jquery-2.x.min.js?1595294628"></script>
 
     <style type="text/css">
       :root #header + #content > #left > #rlblock_left{
@@ -83,14 +83,14 @@
     <span data-search-clear=""><i class="fas fa-times"></i></span>
 </div>
 
-<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595208214"></script>
-<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595294628"></script>
+<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595294628"></script>
 <script type="text/javascript">
     
         var baseurl = "https:\/\/www.eclipse.org\/hono\/docs\/";
     
 </script>
-<script type="text/javascript" src="/hono/docs/js/search.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/search.js?1595294628"></script>
 
     
   </div>
@@ -315,9 +315,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/user-guide/device-registry/" title="Device Registry" class="dd-item ">
-        <a href="/hono/docs/user-guide/device-registry/">
-        Device Registry
+      <li data-nav-id="/hono/docs/user-guide/mongodb-based-device-registry/" title="MongoDB Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/mongodb-based-device-registry/">
+        MongoDB Based Device Registry
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/user-guide/file-based-device-registry/" title="File Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/file-based-device-registry/">
+        File Based Device Registry
         
         </a>
     </li>
@@ -537,9 +556,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/device-registry-config/" title="Device Registry Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/device-registry-config/">
-        Device Registry Configuration
+      <li data-nav-id="/hono/docs/admin-guide/mongodb-device-registry-config/" title="MongoDB Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mongodb-device-registry-config/">
+        MongoDB Based Device Registry Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/admin-guide/file-based-device-registry-config/" title="File Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/file-based-device-registry-config/">
+        File Based Device Registry Configuration
         
         </a>
     </li>
@@ -594,6 +632,25 @@
  
   
     
+      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
+        MQTT Adapter Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
       <li data-nav-id="/hono/docs/admin-guide/amqp-adapter-config/" title="AMQP Adapter Configuration" class="dd-item ">
         <a href="/hono/docs/admin-guide/amqp-adapter-config/">
         AMQP Adapter Configuration
@@ -613,9 +670,9 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
-        MQTT Adapter Configuration
+      <li data-nav-id="/hono/docs/admin-guide/coap-adapter-config/" title="CoAP Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/coap-adapter-config/">
+        CoAP Adapter Configuration
         
         </a>
     </li>
@@ -1277,7 +1334,27 @@
                   
                     
                     
-                      <option id="stable" value="/hono/docs/user-guide/http-adapter/" selected>stable (1.2)</option>
+                      <option id="stable" value="/hono/docs/user-guide/http-adapter/" selected>stable (1.3)</option>
+                    
+                  
+              
+                  
+              
+                  
+              
+                  
+              
+                  
+              
+          
+              
+              
+                  
+              
+                  
+                    
+                    
+                      <option id="1.2" value="/hono/docs/1.2/user-guide/http-adapter/">1.2</option>
                     
                   
               
@@ -1293,6 +1370,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="1.1" value="/hono/docs/1.1/user-guide/http-adapter/">1.1</option>
@@ -1311,6 +1390,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="1.0" value="/hono/docs/1.0/user-guide/http-adapter/">1.0</option>
@@ -1329,6 +1410,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="dev" value="/hono/docs/dev/user-guide/http-adapter/">dev</option>
@@ -1519,7 +1602,14 @@
 
 <h2 id="message-limits">Message Limits</h2>
 
-<p>Before accepting any telemetry or event or command messages, the HTTP adapter verifies that the configured <a href="/hono/docs/concepts/resource-limits/">message limit</a> is not exceeded. If the limit is exceeded then the incoming message is discarded with the status code <code>429 Too Many Requests</code>.</p>
+<p>The adapter rejects</p>
+
+<ul>
+<li>a client&rsquo;s request to upload data with status code <code>429 Too Many Requests</code> and</li>
+<li>any AMQP 1.0 message containing a command sent by a north bound application</li>
+</ul>
+
+<p>if the <a href="/hono/docs/concepts/resource-limits/">message limit</a> that has been configured for the device&rsquo;s tenant is exceeded.</p>
 
 <h2 id="publish-telemetry-data-authenticated-device">Publish Telemetry Data (authenticated Device)</h2>
 
@@ -2060,7 +2150,7 @@
 
 <h3 id="commands-handled-by-gateways">Commands handled by gateways</h3>
 
-<p>Authenticated gateways will receive commands for devices which do not connect to a protocol adapter directly but instead are connected to the gateway. Corresponding devices have to be configured so that they can be used with a gateway. See <a href="/hono/docs/admin-guide/device-registry-config/#configuring-gateway-devices">Configuring Gateway Devices</a> for details.</p>
+<p>Authenticated gateways will receive commands for devices which do not connect to a protocol adapter directly but instead are connected to the gateway. Corresponding devices have to be configured so that they can be used with a gateway. See <a href="/hono/docs/admin-guide/file-based-device-registry-config/#configuring-gateway-devices">Configuring Gateway Devices</a> for details.</p>
 
 <p>A gateway can send a request with the <code>hono-ttd</code> header or query parameter on the <code>/event</code> or <code>/telemetry</code> URI, indicating its readiness to receive a command for <em>any</em> device it acts on behalf of. Note that in this case, the business application will be notified with the gateway id in the <code>device_id</code> property of the downstream message.</p>
 
@@ -2546,6 +2636,22 @@
             
                 
                     
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
                     
                 
                 
@@ -2865,6 +2971,38 @@
             
         
                     
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
             
         
                     
@@ -3267,20 +3405,20 @@
     <div style="left: -1000px; overflow: scroll; position: absolute; top: -1000px; border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;">
       <div style="border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;"></div>
     </div>
-    <script src="/hono/docs/js/clipboard.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595208214"></script>
-    <script src="/hono/docs/js/jquery.sticky.js?1595208214"></script>
-    <script src="/hono/docs/js/featherlight.min.js?1595208214"></script>
-    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595208214"></script>
-    <script src="/hono/docs/js/highlight.pack.js?1595208214"></script>
+    <script src="/hono/docs/js/clipboard.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595294628"></script>
+    <script src="/hono/docs/js/jquery.sticky.js?1595294628"></script>
+    <script src="/hono/docs/js/featherlight.min.js?1595294628"></script>
+    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595294628"></script>
+    <script src="/hono/docs/js/highlight.pack.js?1595294628"></script>
     <script>hljs.initHighlightingOnLoad();</script>
-    <script src="/hono/docs/js/modernizr.custom.71422.js?1595208214"></script>
-    <script src="/hono/docs/js/learn.js?1595208214"></script>
-    <script src="/hono/docs/js/hugo-learn.js?1595208214"></script>
+    <script src="/hono/docs/js/modernizr.custom.71422.js?1595294628"></script>
+    <script src="/hono/docs/js/learn.js?1595294628"></script>
+    <script src="/hono/docs/js/hugo-learn.js?1595294628"></script>
 
-    <link href="/hono/docs/mermaid/mermaid.css?1595208214" type="text/css" rel="stylesheet" />
-    <script src="/hono/docs/mermaid/mermaid.js?1595208214"></script>
+    <link href="/hono/docs/mermaid/mermaid.css?1595294628" type="text/css" rel="stylesheet" />
+    <script src="/hono/docs/mermaid/mermaid.js?1595294628"></script>
     <script>
         mermaid.initialize({ startOnLoad: true });
     </script>
diff --git a/docs/user-guide/index.html b/docs/user-guide/index.html
index c25de80..427829d 100644
--- a/docs/user-guide/index.html
+++ b/docs/user-guide/index.html
@@ -21,19 +21,19 @@
     <title>User Guide :: Eclipse Hono&trade;</title>
 
     
-    <link href="/hono/docs/css/nucleus.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/fontawesome-all.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hybrid.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/featherlight.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/auto-complete.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/theme.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hugo-theme.css?1595208214" rel="stylesheet">
+    <link href="/hono/docs/css/nucleus.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/fontawesome-all.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hybrid.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/featherlight.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/auto-complete.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/theme.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hugo-theme.css?1595294628" rel="stylesheet">
     
-      <link href="/hono/docs/css/theme-hono.css?1595208214" rel="stylesheet">
+      <link href="/hono/docs/css/theme-hono.css?1595294628" rel="stylesheet">
     
 
-    <script src="/hono/docs/js/jquery-2.x.min.js?1595208214"></script>
+    <script src="/hono/docs/js/jquery-2.x.min.js?1595294628"></script>
 
     <style type="text/css">
       :root #header + #content > #left > #rlblock_left{
@@ -83,14 +83,14 @@
     <span data-search-clear=""><i class="fas fa-times"></i></span>
 </div>
 
-<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595208214"></script>
-<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595294628"></script>
+<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595294628"></script>
 <script type="text/javascript">
     
         var baseurl = "https:\/\/www.eclipse.org\/hono\/docs\/";
     
 </script>
-<script type="text/javascript" src="/hono/docs/js/search.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/search.js?1595294628"></script>
 
     
   </div>
@@ -315,9 +315,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/user-guide/device-registry/" title="Device Registry" class="dd-item ">
-        <a href="/hono/docs/user-guide/device-registry/">
-        Device Registry
+      <li data-nav-id="/hono/docs/user-guide/mongodb-based-device-registry/" title="MongoDB Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/mongodb-based-device-registry/">
+        MongoDB Based Device Registry
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/user-guide/file-based-device-registry/" title="File Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/file-based-device-registry/">
+        File Based Device Registry
         
         </a>
     </li>
@@ -537,9 +556,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/device-registry-config/" title="Device Registry Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/device-registry-config/">
-        Device Registry Configuration
+      <li data-nav-id="/hono/docs/admin-guide/mongodb-device-registry-config/" title="MongoDB Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mongodb-device-registry-config/">
+        MongoDB Based Device Registry Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/admin-guide/file-based-device-registry-config/" title="File Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/file-based-device-registry-config/">
+        File Based Device Registry Configuration
         
         </a>
     </li>
@@ -594,6 +632,25 @@
  
   
     
+      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
+        MQTT Adapter Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
       <li data-nav-id="/hono/docs/admin-guide/amqp-adapter-config/" title="AMQP Adapter Configuration" class="dd-item ">
         <a href="/hono/docs/admin-guide/amqp-adapter-config/">
         AMQP Adapter Configuration
@@ -613,9 +670,9 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
-        MQTT Adapter Configuration
+      <li data-nav-id="/hono/docs/admin-guide/coap-adapter-config/" title="CoAP Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/coap-adapter-config/">
+        CoAP Adapter Configuration
         
         </a>
     </li>
@@ -1277,7 +1334,27 @@
                   
                     
                     
-                      <option id="stable" value="/hono/docs/user-guide/" selected>stable (1.2)</option>
+                      <option id="stable" value="/hono/docs/user-guide/" selected>stable (1.3)</option>
+                    
+                  
+              
+                  
+              
+                  
+              
+                  
+              
+                  
+              
+          
+              
+              
+                  
+              
+                  
+                    
+                    
+                      <option id="1.2" value="/hono/docs/1.2/user-guide/">1.2</option>
                     
                   
               
@@ -1293,6 +1370,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="1.1" value="/hono/docs/1.1/user-guide/">1.1</option>
@@ -1311,6 +1390,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="1.0" value="/hono/docs/1.0/user-guide/">1.0</option>
@@ -1329,6 +1410,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="dev" value="/hono/docs/dev/user-guide/">dev</option>
@@ -1775,6 +1858,22 @@
             
         
                     
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
             
         
                     
@@ -1983,6 +2082,38 @@
             
         
                     
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
             
         
                     
@@ -2385,20 +2516,20 @@
     <div style="left: -1000px; overflow: scroll; position: absolute; top: -1000px; border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;">
       <div style="border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;"></div>
     </div>
-    <script src="/hono/docs/js/clipboard.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595208214"></script>
-    <script src="/hono/docs/js/jquery.sticky.js?1595208214"></script>
-    <script src="/hono/docs/js/featherlight.min.js?1595208214"></script>
-    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595208214"></script>
-    <script src="/hono/docs/js/highlight.pack.js?1595208214"></script>
+    <script src="/hono/docs/js/clipboard.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595294628"></script>
+    <script src="/hono/docs/js/jquery.sticky.js?1595294628"></script>
+    <script src="/hono/docs/js/featherlight.min.js?1595294628"></script>
+    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595294628"></script>
+    <script src="/hono/docs/js/highlight.pack.js?1595294628"></script>
     <script>hljs.initHighlightingOnLoad();</script>
-    <script src="/hono/docs/js/modernizr.custom.71422.js?1595208214"></script>
-    <script src="/hono/docs/js/learn.js?1595208214"></script>
-    <script src="/hono/docs/js/hugo-learn.js?1595208214"></script>
+    <script src="/hono/docs/js/modernizr.custom.71422.js?1595294628"></script>
+    <script src="/hono/docs/js/learn.js?1595294628"></script>
+    <script src="/hono/docs/js/hugo-learn.js?1595294628"></script>
 
-    <link href="/hono/docs/mermaid/mermaid.css?1595208214" type="text/css" rel="stylesheet" />
-    <script src="/hono/docs/mermaid/mermaid.js?1595208214"></script>
+    <link href="/hono/docs/mermaid/mermaid.css?1595294628" type="text/css" rel="stylesheet" />
+    <script src="/hono/docs/mermaid/mermaid.js?1595294628"></script>
     <script>
         mermaid.initialize({ startOnLoad: true });
     </script>
diff --git a/docs/user-guide/index.xml b/docs/user-guide/index.xml
index b8b60c8..757ebc3 100644
--- a/docs/user-guide/index.xml
+++ b/docs/user-guide/index.xml
@@ -11,11 +11,20 @@
     
     
     <item>
-      <title>Device Registry</title>
-      <link>https://www.eclipse.org/hono/docs/user-guide/device-registry/</link>
+      <title>MongoDB Based Device Registry</title>
+      <link>https://www.eclipse.org/hono/docs/user-guide/mongodb-based-device-registry/</link>
       <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
       
-      <guid>https://www.eclipse.org/hono/docs/user-guide/device-registry/</guid>
+      <guid>https://www.eclipse.org/hono/docs/user-guide/mongodb-based-device-registry/</guid>
+      <description>The MongoDB based Device Registry component provides implementations of Hono&amp;rsquo;s Tenant API, Device Registration API and Credentials API. As such it exposes AMQP 1.0 based endpoints for retrieving the relevant information. Protocol adapters use these APIs to determine a device&amp;rsquo;s registration status, e.g. if it is enabled and if it is registered with a particular tenant, and to authenticate a device before accepting any data for processing from it.</description>
+    </item>
+    
+    <item>
+      <title>File Based Device Registry</title>
+      <link>https://www.eclipse.org/hono/docs/user-guide/file-based-device-registry/</link>
+      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
+      
+      <guid>https://www.eclipse.org/hono/docs/user-guide/file-based-device-registry/</guid>
       <description>&lt;p&gt;The Device Registry component provides exemplary implementations of Hono&amp;rsquo;s &lt;a href=&#34;https://www.eclipse.org/hono/docs/hono/docs/api/tenant/&#34;&gt;Tenant API&lt;/a&gt;, &lt;a href=&#34;https://www.eclipse.org/hono/docs/hono/docs/api/device-registration/&#34;&gt;Device Registration API&lt;/a&gt; and &lt;a href=&#34;https://www.eclipse.org/hono/docs/hono/docs/api/credentials/&#34;&gt;Credentials API&lt;/a&gt;.&lt;/p&gt;</description>
     </item>
     
diff --git a/docs/user-guide/jmeter_load_tests/index.html b/docs/user-guide/jmeter_load_tests/index.html
index 4f9b62e..692c549 100644
--- a/docs/user-guide/jmeter_load_tests/index.html
+++ b/docs/user-guide/jmeter_load_tests/index.html
@@ -21,19 +21,19 @@
     <title>Load Tests with JMeter :: Eclipse Hono&trade;</title>
 
     
-    <link href="/hono/docs/css/nucleus.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/fontawesome-all.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hybrid.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/featherlight.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/auto-complete.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/theme.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hugo-theme.css?1595208214" rel="stylesheet">
+    <link href="/hono/docs/css/nucleus.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/fontawesome-all.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hybrid.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/featherlight.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/auto-complete.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/theme.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hugo-theme.css?1595294628" rel="stylesheet">
     
-      <link href="/hono/docs/css/theme-hono.css?1595208214" rel="stylesheet">
+      <link href="/hono/docs/css/theme-hono.css?1595294628" rel="stylesheet">
     
 
-    <script src="/hono/docs/js/jquery-2.x.min.js?1595208214"></script>
+    <script src="/hono/docs/js/jquery-2.x.min.js?1595294628"></script>
 
     <style type="text/css">
       :root #header + #content > #left > #rlblock_left{
@@ -83,14 +83,14 @@
     <span data-search-clear=""><i class="fas fa-times"></i></span>
 </div>
 
-<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595208214"></script>
-<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595294628"></script>
+<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595294628"></script>
 <script type="text/javascript">
     
         var baseurl = "https:\/\/www.eclipse.org\/hono\/docs\/";
     
 </script>
-<script type="text/javascript" src="/hono/docs/js/search.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/search.js?1595294628"></script>
 
     
   </div>
@@ -315,9 +315,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/user-guide/device-registry/" title="Device Registry" class="dd-item ">
-        <a href="/hono/docs/user-guide/device-registry/">
-        Device Registry
+      <li data-nav-id="/hono/docs/user-guide/mongodb-based-device-registry/" title="MongoDB Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/mongodb-based-device-registry/">
+        MongoDB Based Device Registry
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/user-guide/file-based-device-registry/" title="File Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/file-based-device-registry/">
+        File Based Device Registry
         
         </a>
     </li>
@@ -537,9 +556,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/device-registry-config/" title="Device Registry Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/device-registry-config/">
-        Device Registry Configuration
+      <li data-nav-id="/hono/docs/admin-guide/mongodb-device-registry-config/" title="MongoDB Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mongodb-device-registry-config/">
+        MongoDB Based Device Registry Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/admin-guide/file-based-device-registry-config/" title="File Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/file-based-device-registry-config/">
+        File Based Device Registry Configuration
         
         </a>
     </li>
@@ -594,6 +632,25 @@
  
   
     
+      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
+        MQTT Adapter Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
       <li data-nav-id="/hono/docs/admin-guide/amqp-adapter-config/" title="AMQP Adapter Configuration" class="dd-item ">
         <a href="/hono/docs/admin-guide/amqp-adapter-config/">
         AMQP Adapter Configuration
@@ -613,9 +670,9 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
-        MQTT Adapter Configuration
+      <li data-nav-id="/hono/docs/admin-guide/coap-adapter-config/" title="CoAP Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/coap-adapter-config/">
+        CoAP Adapter Configuration
         
         </a>
     </li>
@@ -1277,7 +1334,27 @@
                   
                     
                     
-                      <option id="stable" value="/hono/docs/user-guide/jmeter_load_tests/" selected>stable (1.2)</option>
+                      <option id="stable" value="/hono/docs/user-guide/jmeter_load_tests/" selected>stable (1.3)</option>
+                    
+                  
+              
+                  
+              
+                  
+              
+                  
+              
+                  
+              
+          
+              
+              
+                  
+              
+                  
+                    
+                    
+                      <option id="1.2" value="/hono/docs/1.2/user-guide/jmeter_load_tests/">1.2</option>
                     
                   
               
@@ -1293,6 +1370,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="1.1" value="/hono/docs/1.1/user-guide/jmeter_load_tests/">1.1</option>
@@ -1311,6 +1390,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="1.0" value="/hono/docs/1.0/user-guide/jmeter_load_tests/">1.0</option>
@@ -1329,6 +1410,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="dev" value="/hono/docs/dev/user-guide/jmeter_load_tests/">dev</option>
@@ -1811,6 +1894,22 @@
             
                 
                     
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
                     
                 
                 
@@ -2034,6 +2133,38 @@
             
         
                     
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
             
         
                     
@@ -2436,20 +2567,20 @@
     <div style="left: -1000px; overflow: scroll; position: absolute; top: -1000px; border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;">
       <div style="border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;"></div>
     </div>
-    <script src="/hono/docs/js/clipboard.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595208214"></script>
-    <script src="/hono/docs/js/jquery.sticky.js?1595208214"></script>
-    <script src="/hono/docs/js/featherlight.min.js?1595208214"></script>
-    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595208214"></script>
-    <script src="/hono/docs/js/highlight.pack.js?1595208214"></script>
+    <script src="/hono/docs/js/clipboard.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595294628"></script>
+    <script src="/hono/docs/js/jquery.sticky.js?1595294628"></script>
+    <script src="/hono/docs/js/featherlight.min.js?1595294628"></script>
+    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595294628"></script>
+    <script src="/hono/docs/js/highlight.pack.js?1595294628"></script>
     <script>hljs.initHighlightingOnLoad();</script>
-    <script src="/hono/docs/js/modernizr.custom.71422.js?1595208214"></script>
-    <script src="/hono/docs/js/learn.js?1595208214"></script>
-    <script src="/hono/docs/js/hugo-learn.js?1595208214"></script>
+    <script src="/hono/docs/js/modernizr.custom.71422.js?1595294628"></script>
+    <script src="/hono/docs/js/learn.js?1595294628"></script>
+    <script src="/hono/docs/js/hugo-learn.js?1595294628"></script>
 
-    <link href="/hono/docs/mermaid/mermaid.css?1595208214" type="text/css" rel="stylesheet" />
-    <script src="/hono/docs/mermaid/mermaid.js?1595208214"></script>
+    <link href="/hono/docs/mermaid/mermaid.css?1595294628" type="text/css" rel="stylesheet" />
+    <script src="/hono/docs/mermaid/mermaid.js?1595294628"></script>
     <script>
         mermaid.initialize({ startOnLoad: true });
     </script>
diff --git a/docs/user-guide/kura-adapter/index.html b/docs/user-guide/kura-adapter/index.html
index 333b335..d2ca0c3 100644
--- a/docs/user-guide/kura-adapter/index.html
+++ b/docs/user-guide/kura-adapter/index.html
@@ -21,19 +21,19 @@
     <title>Kura Adapter :: Eclipse Hono&trade;</title>
 
     
-    <link href="/hono/docs/css/nucleus.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/fontawesome-all.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hybrid.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/featherlight.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/auto-complete.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/theme.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hugo-theme.css?1595208214" rel="stylesheet">
+    <link href="/hono/docs/css/nucleus.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/fontawesome-all.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hybrid.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/featherlight.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/auto-complete.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/theme.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hugo-theme.css?1595294628" rel="stylesheet">
     
-      <link href="/hono/docs/css/theme-hono.css?1595208214" rel="stylesheet">
+      <link href="/hono/docs/css/theme-hono.css?1595294628" rel="stylesheet">
     
 
-    <script src="/hono/docs/js/jquery-2.x.min.js?1595208214"></script>
+    <script src="/hono/docs/js/jquery-2.x.min.js?1595294628"></script>
 
     <style type="text/css">
       :root #header + #content > #left > #rlblock_left{
@@ -83,14 +83,14 @@
     <span data-search-clear=""><i class="fas fa-times"></i></span>
 </div>
 
-<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595208214"></script>
-<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595294628"></script>
+<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595294628"></script>
 <script type="text/javascript">
     
         var baseurl = "https:\/\/www.eclipse.org\/hono\/docs\/";
     
 </script>
-<script type="text/javascript" src="/hono/docs/js/search.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/search.js?1595294628"></script>
 
     
   </div>
@@ -315,9 +315,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/user-guide/device-registry/" title="Device Registry" class="dd-item ">
-        <a href="/hono/docs/user-guide/device-registry/">
-        Device Registry
+      <li data-nav-id="/hono/docs/user-guide/mongodb-based-device-registry/" title="MongoDB Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/mongodb-based-device-registry/">
+        MongoDB Based Device Registry
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/user-guide/file-based-device-registry/" title="File Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/file-based-device-registry/">
+        File Based Device Registry
         
         </a>
     </li>
@@ -537,9 +556,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/device-registry-config/" title="Device Registry Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/device-registry-config/">
-        Device Registry Configuration
+      <li data-nav-id="/hono/docs/admin-guide/mongodb-device-registry-config/" title="MongoDB Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mongodb-device-registry-config/">
+        MongoDB Based Device Registry Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/admin-guide/file-based-device-registry-config/" title="File Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/file-based-device-registry-config/">
+        File Based Device Registry Configuration
         
         </a>
     </li>
@@ -594,6 +632,25 @@
  
   
     
+      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
+        MQTT Adapter Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
       <li data-nav-id="/hono/docs/admin-guide/amqp-adapter-config/" title="AMQP Adapter Configuration" class="dd-item ">
         <a href="/hono/docs/admin-guide/amqp-adapter-config/">
         AMQP Adapter Configuration
@@ -613,9 +670,9 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
-        MQTT Adapter Configuration
+      <li data-nav-id="/hono/docs/admin-guide/coap-adapter-config/" title="CoAP Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/coap-adapter-config/">
+        CoAP Adapter Configuration
         
         </a>
     </li>
@@ -1277,7 +1334,27 @@
                   
                     
                     
-                      <option id="stable" value="/hono/docs/user-guide/kura-adapter/" selected>stable (1.2)</option>
+                      <option id="stable" value="/hono/docs/user-guide/kura-adapter/" selected>stable (1.3)</option>
+                    
+                  
+              
+                  
+              
+                  
+              
+                  
+              
+                  
+              
+          
+              
+              
+                  
+              
+                  
+                    
+                    
+                      <option id="1.2" value="/hono/docs/1.2/user-guide/kura-adapter/">1.2</option>
                     
                   
               
@@ -1293,6 +1370,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="1.1" value="/hono/docs/1.1/user-guide/kura-adapter/">1.1</option>
@@ -1311,6 +1390,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="1.0" value="/hono/docs/1.0/user-guide/kura-adapter/">1.0</option>
@@ -1329,6 +1410,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="dev" value="/hono/docs/dev/user-guide/kura-adapter/">dev</option>
@@ -1445,6 +1528,19 @@
 <ul>
 <li>
 <ul>
+<li><a href="#authentication">Authentication</a>
+<ul>
+<li><a href="#client-certificate">Client Certificate</a></li>
+<li><a href="#username-password">Username/Password</a></li>
+</ul></li>
+<li><a href="#resource-limit-checks">Resource Limit Checks</a>
+<ul>
+<li><a href="#connection-limits">Connection Limits</a></li>
+<li><a href="#connection-duration-limits">Connection Duration Limits</a></li>
+<li><a href="#message-limits">Message Limits</a></li>
+</ul></li>
+<li><a href="#connection-events">Connection Events</a></li>
+<li><a href="#publishing-data">Publishing Data</a></li>
 <li><a href="#downstream-meta-data">Downstream Meta Data</a>
 <ul>
 <li><a href="#event-message-time-to-live">Event Message Time-to-live</a></li>
@@ -1478,18 +1574,95 @@
 </div>
 
 
-<p>The Kura adapter by default requires devices (gateways) to authenticate during connection establishment. In order to do so, gateways need to provide a <em>username</em> and a <em>password</em> in the MQTT <em>CONNECT</em> packet. The <em>username</em> must have the form <em>auth-id@tenant</em>, e.g. <code>sensor1@DEFAULT_TENANT</code>. The adapter verifies the credentials provided by the gateway against the credentials the <a href="/hono/docs/admin-guide/common-config/#credentials-service-connection-configuration">configured Credentials service</a> has on record for the gateway. The adapter uses the Credentials API&rsquo;s <em>get</em> operation to retrieve the credentials-on-record with the <em>tenant</em> and <em>auth-id</em> provided by the device in the <em>username</em> and <code>hashed-password</code> as the <em>type</em> of secret as query parameters.</p>
+<h2 id="authentication">Authentication</h2>
 
-<p>Please refer to the <a href="http://eclipse.github.io/kura/config/cloud-services.html">Eclipse Kura documentation</a> on how to configure the gateway&rsquo;s cloud service connection accordingly. It is important to set the gateway&rsquo;s <em>topic.context.account-name</em> to the ID of the Hono tenant that the gateway has been registered with whereas the gateway&rsquo;s <em>client-id</em> needs to be set to the corresponding Hono device ID. The <em>auth-id</em> used as part of the gateway&rsquo;s <em>username</em> property needs to match the authentication identifier of a set of credentials registered for the device ID in Hono&rsquo;s Credentials service. In other words, the credentials configured on the gateway need to belong to the corresponding device ID.</p>
+<p>The Kura adapter by default requires devices (gateways) to authenticate during connection establishment.
+The adapter supports both the authentication based on the username/password provided in an MQTT CONNECT packet as well as client
+certificate based authentication as part of a TLS handshake for that purpose.</p>
 
-<p>After verifying the credentials, the number of existing connections and the overall amount of time that the devices have already been connected are checked against the configured <a href="/hono/docs/concepts/resource-limits/">resource-limits</a> by the Kura adapter.  If the limit is exceeded then a return code <code>0x05</code> indicating <code>Connection Refused: not authorised</code> is sent back.</p>
+<p>The adapter tries to authenticate the device using these mechanisms in the following order</p>
 
-<p>Once the gateway has established a connection to the Kura adapter, all <em>control</em> and <em>data</em> messages published by applications running on the gateway are sent to the adapter and mapped to Hono&rsquo;s Telemetry and Event API endpoints as follows:</p>
+<h3 id="client-certificate">Client Certificate</h3>
+
+<p>When a device uses a client certificate for authentication during the TLS handshake, the adapter tries to determine the tenant
+that the device belongs to based on the <em>issuer DN</em> contained in the certificate.
+In order for the lookup to succeed, the tenant&rsquo;s trust anchor needs to be configured by means of registering the
+<a href="/hono/docs/api/tenant/#tenant-information-format">trusted certificate authority</a>. The device&rsquo;s client certificate will then be
+validated using the registered trust anchor, thus implicitly establishing the tenant that the device belongs to.
+In a second step, the adapter uses the Credentials API&rsquo;s <em>get</em> operation to retrieve the credentials on record, including the client
+certificate&rsquo;s <em>subject DN</em> as the <em>auth-id</em>, <code>x509-cert</code> as the <em>type</em> of secret and the MQTT client identifier as <em>client-id</em> in the
+request payload.</p>
+
+<p><strong>NB</strong> The adapter needs to be <a href="/hono/docs/admin-guide/secure_communication/#mqtt-adapter">configured for TLS</a> in order to support this mechanism.</p>
+
+<h3 id="username-password">Username/Password</h3>
+
+<p>When a device wants to authenticate using this mechanism, it needs to provide a <em>username</em> and a <em>password</em> in the MQTT <em>CONNECT</em> packet
+it sends in order to initiate the connection. The <em>username</em> must have the form <em>auth-id@tenant</em>, e.g. <code>sensor1@DEFAULT_TENANT</code>.
+The adapter verifies the credentials provided by the client against the credentials that the
+<a href="/hono/docs/admin-guide/common-config/#credentials-service-connection-configuration">configured Credentials service</a> has on record for the client.
+The adapter uses the Credentials API&rsquo;s <em>get</em> operation to retrieve the credentials on record, including the <em>tenant</em> and <em>auth-id</em> provided
+by the client in the <em>username</em>, <code>hashed-password</code> as the <em>type</em> of secret and the MQTT client identifier as <em>client-id</em> in the request payload.</p>
+
+<p>Please refer to the <a href="http://eclipse.github.io/kura/config/cloud-services.html">Eclipse Kura documentation</a> on how to configure the
+gateway&rsquo;s cloud service connection accordingly. It is important to set the gateway&rsquo;s <em>topic.context.account-name</em> to the ID of the
+Hono tenant that the gateway has been registered with whereas the gateway&rsquo;s <em>client-id</em> needs to be set to the corresponding Hono
+device ID. The <em>auth-id</em> used as part of the gateway&rsquo;s <em>username</em> property needs to match the authentication identifier of a set of
+credentials registered for the device ID in Hono&rsquo;s Credentials service. In other words, the credentials configured on the gateway
+need to belong to the corresponding device ID.</p>
+
+<p><strong>NB</strong> There is a subtle difference between the <em>device identifier</em> (<em>device-id</em>) and the <em>auth-id</em> a device uses for authentication.
+See <a href="/hono/docs/concepts/device-identity/">Device Identity</a> for a discussion of the concepts.</p>
+
+<h2 id="resource-limit-checks">Resource Limit Checks</h2>
+
+<p>The adapter performs additional checks regarding resource limits when a client tries to connect and/or send a message to the adapter.</p>
+
+<h3 id="connection-limits">Connection Limits</h3>
+
+<p>The adapter rejects a client&rsquo;s connection attempt with return code <code>0x05</code>, indicating <code>Connection Refused: not authorized</code>, if
+* the maximum number of connections per protocol adapter instance is reached, or
+* if the maximum number of simultaneously connected devices for the tenant is reached.</p>
+
+<p>Please refer to <a href="/hono/docs/concepts/resource-limits/">resource-limits</a> for details.</p>
+
+<h3 id="connection-duration-limits">Connection Duration Limits</h3>
+
+<p>The adapter rejects a client&rsquo;s connection attempt with return code <code>0x05</code>, indicating <code>Connection Refused: not authorized</code>, if the
+<a href="/hono/docs/concepts/resource-limits/#connection-duration-limit">connection duration limit</a> that has been configured for
+the client&rsquo;s tenant is exceeded.</p>
+
+<h3 id="message-limits">Message Limits</h3>
+
+<p>The adapter</p>
+
+<ul>
+<li>discards any MQTT PUBLISH packet containing telemetry data or an event that is sent by a client and</li>
+<li>rejects any AMQP 1.0 message containing a command sent by a north bound application</li>
+</ul>
+
+<p>if the <a href="/hono/docs/concepts/resource-limits/">message limit</a> that has been configured for the device&rsquo;s tenant is exceeded.</p>
+
+<h2 id="connection-events">Connection Events</h2>
+
+<p>The adapter can emit <a href="/hono/docs/api/event/#connection-event">Connection Events</a> for client connections being established and/or terminated.
+Please refer to the <a href="/hono/docs/admin-guide/common-config/#connection-event-producer-configuration">common configuration options</a>
+for details regarding how to enable this behavior.</p>
+
+<p>The adapter includes the <em>client identifier</em> from the client&rsquo;s MQTT CONNECT packet as the Connection Event&rsquo;s <em>remote-id</em>.</p>
+
+<h2 id="publishing-data">Publishing Data</h2>
+
+<p>Once the gateway has established a connection to the Kura adapter, all <em>control</em> and <em>data</em> messages published by applications running on
+the gateway are sent to the adapter and mapped to Hono&rsquo;s Telemetry and Event API endpoints as follows:</p>
 
 <ol>
-<li>The adapter treats all messages that are published to a topic starting with the configured <code>HONO_KURA_CONTROL_PREFIX</code> as control messages. All other messages are considered to be data messages.</li>
-<li><em>control</em> messages with QoS 0 are forwarded to Hono&rsquo;s telemetry endpoint whereas messages with QoS 1 are forwarded to the event endpoint. The corresponding AMQP 1.0 messages that are sent downstream have a content type of <code>application/vnd.eclipse.kura-control</code>.</li>
-<li><em>data</em> messages with QoS 0 are forwarded to the telemetry endpoint whereas messages with QoS 1 are forwarded to the event endpoint. The corresponding AMQP 1.0 messages that are sent downstream have a content type of <code>application/vnd.eclipse.kura-data</code>.</li>
+<li>The adapter treats all messages that are published to a topic starting with the configured <code>HONO_KURA_CONTROL_PREFIX</code> as control messages.
+All other messages are considered to be data messages.</li>
+<li><em>control</em> messages with QoS 0 are forwarded to Hono&rsquo;s telemetry endpoint whereas messages with QoS 1 are forwarded to the event endpoint.
+The corresponding AMQP 1.0 messages that are sent downstream have a content type of <code>application/vnd.eclipse.kura-control</code>.</li>
+<li><em>data</em> messages with QoS 0 are forwarded to the telemetry endpoint whereas messages with QoS 1 are forwarded to the event endpoint.
+The corresponding AMQP 1.0 messages that are sent downstream have a content type of <code>application/vnd.eclipse.kura-data</code>.</li>
 </ol>
 
 <h2 id="downstream-meta-data">Downstream Meta Data</h2>
@@ -1854,6 +2027,22 @@
             
                 
                     
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
                     
                 
                 
@@ -2109,6 +2298,38 @@
             
         
                     
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
             
         
                     
@@ -2511,20 +2732,20 @@
     <div style="left: -1000px; overflow: scroll; position: absolute; top: -1000px; border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;">
       <div style="border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;"></div>
     </div>
-    <script src="/hono/docs/js/clipboard.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595208214"></script>
-    <script src="/hono/docs/js/jquery.sticky.js?1595208214"></script>
-    <script src="/hono/docs/js/featherlight.min.js?1595208214"></script>
-    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595208214"></script>
-    <script src="/hono/docs/js/highlight.pack.js?1595208214"></script>
+    <script src="/hono/docs/js/clipboard.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595294628"></script>
+    <script src="/hono/docs/js/jquery.sticky.js?1595294628"></script>
+    <script src="/hono/docs/js/featherlight.min.js?1595294628"></script>
+    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595294628"></script>
+    <script src="/hono/docs/js/highlight.pack.js?1595294628"></script>
     <script>hljs.initHighlightingOnLoad();</script>
-    <script src="/hono/docs/js/modernizr.custom.71422.js?1595208214"></script>
-    <script src="/hono/docs/js/learn.js?1595208214"></script>
-    <script src="/hono/docs/js/hugo-learn.js?1595208214"></script>
+    <script src="/hono/docs/js/modernizr.custom.71422.js?1595294628"></script>
+    <script src="/hono/docs/js/learn.js?1595294628"></script>
+    <script src="/hono/docs/js/hugo-learn.js?1595294628"></script>
 
-    <link href="/hono/docs/mermaid/mermaid.css?1595208214" type="text/css" rel="stylesheet" />
-    <script src="/hono/docs/mermaid/mermaid.js?1595208214"></script>
+    <link href="/hono/docs/mermaid/mermaid.css?1595294628" type="text/css" rel="stylesheet" />
+    <script src="/hono/docs/mermaid/mermaid.js?1595294628"></script>
     <script>
         mermaid.initialize({ startOnLoad: true });
     </script>
diff --git a/docs/user-guide/device-registry/index.html b/docs/user-guide/mongodb-based-device-registry/index.html
similarity index 63%
copy from docs/user-guide/device-registry/index.html
copy to docs/user-guide/mongodb-based-device-registry/index.html
index 5ff6a71..7b7b4a0 100644
--- a/docs/user-guide/device-registry/index.html
+++ b/docs/user-guide/mongodb-based-device-registry/index.html
@@ -18,22 +18,22 @@
 <meta name="msapplication-config" content="/hono/docs/favicon/browserconfig.xml">
 <meta name="theme-color" content="#ffffff">
 
-    <title>Device Registry :: Eclipse Hono&trade;</title>
+    <title>MongoDB Based Device Registry :: Eclipse Hono&trade;</title>
 
     
-    <link href="/hono/docs/css/nucleus.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/fontawesome-all.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hybrid.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/featherlight.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/auto-complete.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/theme.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hugo-theme.css?1595208214" rel="stylesheet">
+    <link href="/hono/docs/css/nucleus.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/fontawesome-all.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hybrid.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/featherlight.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/auto-complete.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/theme.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hugo-theme.css?1595294628" rel="stylesheet">
     
-      <link href="/hono/docs/css/theme-hono.css?1595208214" rel="stylesheet">
+      <link href="/hono/docs/css/theme-hono.css?1595294628" rel="stylesheet">
     
 
-    <script src="/hono/docs/js/jquery-2.x.min.js?1595208214"></script>
+    <script src="/hono/docs/js/jquery-2.x.min.js?1595294628"></script>
 
     <style type="text/css">
       :root #header + #content > #left > #rlblock_left{
@@ -53,18 +53,18 @@
 
 <meta name="twitter:card" content="summary_large_image">
 <meta name="twitter:site" content="@EclipseHono">
-<meta name="twitter:title" content="Device Registry :: Eclipse Hono&amp;trade;">
+<meta name="twitter:title" content="MongoDB Based Device Registry :: Eclipse Hono&amp;trade;">
 <meta name="twitter:image" content="https://www.eclipse.org/hono/docs/images/twitter_image.png">
 <meta name="twitter:description" content="A set of micro-services for connecting millions of devices.">
 
 
-<meta property="og:title" content="Device Registry :: Eclipse Hono&amp;trade;" />
+<meta property="og:title" content="MongoDB Based Device Registry :: Eclipse Hono&amp;trade;" />
 <meta property="og:type" content="website" />
-<meta property="og:url" content="https://www.eclipse.org/hono/docs/user-guide/device-registry//" />
+<meta property="og:url" content="https://www.eclipse.org/hono/docs/user-guide/mongodb-based-device-registry//" />
 <meta property="og:image" content="https://www.eclipse.org/hono/docs/images/twitter_image.png" />
 
   </head>
-  <body class="" data-url="/hono/docs/user-guide/device-registry/">
+  <body class="" data-url="/hono/docs/user-guide/mongodb-based-device-registry/">
     <nav id="sidebar" class="">
 
 
@@ -83,14 +83,14 @@
     <span data-search-clear=""><i class="fas fa-times"></i></span>
 </div>
 
-<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595208214"></script>
-<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595294628"></script>
+<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595294628"></script>
 <script type="text/javascript">
     
         var baseurl = "https:\/\/www.eclipse.org\/hono\/docs\/";
     
 </script>
-<script type="text/javascript" src="/hono/docs/js/search.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/search.js?1595294628"></script>
 
     
   </div>
@@ -315,9 +315,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/user-guide/device-registry/" title="Device Registry" class="dd-item active">
-        <a href="/hono/docs/user-guide/device-registry/">
-        Device Registry
+      <li data-nav-id="/hono/docs/user-guide/mongodb-based-device-registry/" title="MongoDB Based Device Registry" class="dd-item active">
+        <a href="/hono/docs/user-guide/mongodb-based-device-registry/">
+        MongoDB Based Device Registry
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/user-guide/file-based-device-registry/" title="File Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/file-based-device-registry/">
+        File Based Device Registry
         
         </a>
     </li>
@@ -537,9 +556,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/device-registry-config/" title="Device Registry Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/device-registry-config/">
-        Device Registry Configuration
+      <li data-nav-id="/hono/docs/admin-guide/mongodb-device-registry-config/" title="MongoDB Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mongodb-device-registry-config/">
+        MongoDB Based Device Registry Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/admin-guide/file-based-device-registry-config/" title="File Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/file-based-device-registry-config/">
+        File Based Device Registry Configuration
         
         </a>
     </li>
@@ -594,6 +632,25 @@
  
   
     
+      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
+        MQTT Adapter Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
       <li data-nav-id="/hono/docs/admin-guide/amqp-adapter-config/" title="AMQP Adapter Configuration" class="dd-item ">
         <a href="/hono/docs/admin-guide/amqp-adapter-config/">
         AMQP Adapter Configuration
@@ -613,9 +670,9 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
-        MQTT Adapter Configuration
+      <li data-nav-id="/hono/docs/admin-guide/coap-adapter-config/" title="CoAP Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/coap-adapter-config/">
+        CoAP Adapter Configuration
         
         </a>
     </li>
@@ -1277,7 +1334,7 @@
                   
                     
                     
-                      <option id="stable" value="/hono/docs/user-guide/device-registry/" selected>stable (1.2)</option>
+                      <option id="stable" value="/hono/docs/user-guide/mongodb-based-device-registry/" selected>stable (1.3)</option>
                     
                   
               
@@ -1287,24 +1344,14 @@
               
                   
               
+                  
+              
           
               
               
                   
               
                   
-                    
-                    
-                      <option id="1.1" value="/hono/docs/1.1/user-guide/device-registry/">1.1</option>
-                    
-                  
-              
-                  
-              
-                  
-              
-          
-              
               
                   
               
@@ -1313,12 +1360,10 @@
                   
                     
                     
-                      <option id="1.0" value="/hono/docs/1.0/user-guide/device-registry/">1.0</option>
+                      <option id="dev" value="/hono/docs/dev/user-guide/mongodb-based-device-registry/">dev</option>
                     
                   
               
-                  
-              
           
         </select>
         <svg version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
@@ -1381,7 +1426,7 @@
                   
                   
                   <div id="top-github-link">
-                    <a class="github-link" title='Edit this page' href="https://github.com/eclipse/hono/edit/master/site/documentation/content/user-guide/device-registry.md" target="blank">
+                    <a class="github-link" title='Edit this page' href="https://github.com/eclipse/hono/edit/master/site/documentation/content/user-guide/mongodb-based-device-registry.md" target="blank">
                       <i class="fas fa-code-branch"></i>
                       <span id="top-github-link-text">Edit this page</span>
                     </a>
@@ -1412,7 +1457,7 @@
             
           
           
-            <a href='/hono/docs/'>Documentation</a> > <a href='/hono/docs/user-guide/'>User Guide</a> > Device Registry
+            <a href='/hono/docs/'>Documentation</a> > <a href='/hono/docs/user-guide/'>User Guide</a> > MongoDB Based Device Registry
           
          
           
@@ -1429,25 +1474,10 @@
 <ul>
 <li>
 <ul>
-<li><a href="#managing-tenants">Managing Tenants</a>
-<ul>
-<li><a href="#add-a-tenant">Add a Tenant</a></li>
-<li><a href="#get-configuration-details-of-a-tenant">Get configuration details of a Tenant</a></li>
-<li><a href="#update-tenant">Update Tenant</a></li>
-<li><a href="#delete-tenant">Delete Tenant</a></li>
-</ul></li>
-<li><a href="#managing-device-registration-information">Managing Device Registration Information</a>
-<ul>
-<li><a href="#register-device">Register Device</a></li>
-<li><a href="#read-device">Read Device</a></li>
-<li><a href="#update-device">Update Device</a></li>
-<li><a href="#delete-device">Delete Device</a></li>
-</ul></li>
-<li><a href="#managing-credentials">Managing Credentials</a>
-<ul>
-<li><a href="#update-credentials-for-a-device">Update Credentials for a Device</a></li>
-<li><a href="#get-all-credentials-for-a-device">Get all Credentials for a Device</a></li>
-</ul></li>
+<li><a href="#authentication">Authentication</a></li>
+<li><a href="#managing-tenants">Managing Tenants</a></li>
+<li><a href="#managing-devices">Managing Devices</a></li>
+<li><a href="#managing-credentials">Managing Credentials</a></li>
 </ul></li>
 </ul>
 </nav>
@@ -1462,541 +1492,34 @@
         
         <div id="body-inner">
           
-            <h1>Device Registry</h1>
+            <h1>MongoDB Based Device Registry</h1>
           
 
         
 
 
-<p>The Device Registry component provides exemplary implementations of Hono&rsquo;s <a href="/hono/docs/api/tenant/">Tenant API</a>, <a href="/hono/docs/api/device-registration/">Device Registration API</a> and <a href="/hono/docs/api/credentials/">Credentials API</a>.</p>
 
-<p>As such it exposes AMQP 1.0 based endpoints for retrieving the relevant information and persists data in the local filesystem.</p>
 
-<p>In addition, the Device Registry also exposes HTTP resources for managing the contents of the registry according to the <a href="/hono/docs/api/management/">Device Registry HTTP API</a>.</p>
+<p>The MongoDB based Device Registry component provides implementations of Hono&rsquo;s <a href="/hono/docs/api/tenant/">Tenant API</a>, <a href="/hono/docs/api/device-registration/">Device Registration API</a> and <a href="/hono/docs/api/credentials/">Credentials API</a>. As such it exposes AMQP 1.0 based endpoints for retrieving the relevant information. Protocol adapters use these APIs to determine a device&rsquo;s registration status, e.g. if it is enabled and if it is registered with a particular tenant, and to authenticate a device before accepting any data for processing from it.</p>
 
-<div class="alert alert-warning">
-    <h4 class="alert-heading"><i class="fas fa-exclamation-triangle"></i> Warning</h4>
-    <div><p>The Device Registry is not intended to be used in production environments. In particular, access to the HTTP resources described below is not restricted to authorized clients only.</p>
+<p>In addition to the above APIs, this Device Registry also exposes HTTP endpoints for managing the contents of the Device Registry according to the <a href="/hono/docs/api/management/">Device Registry Management API</a>. It uses a MongoDB database to persist the data. The credentials, device and tenant information are stored in separate collections in a MongoDB database. For more information on how to configure the MongoDB based device registry, see <a href="/hono/docs/admin-guide/mongodb-device-registry-config/">MongoDB based Device Registry configuration</a>.</p>
 
-<p>The resources have been designed to provide convenient access to the registry&rsquo;s content using command line tools like <em>curl</em> or <em>HTTPie</em>.</p>
-</div>
-</div>
+<h2 id="authentication">Authentication</h2>
 
+<p>This Device Registry secures its HTTP Endpoints using basic authentication mechanism. Thereby the clients connecting to the MongoDB based Device Registry are required to authenticate. For more information on how to enable the authentication and configure it, please refer to the <code>hono.registry.http.authenticationRequired</code> property in the <a href="/hono/docs/admin-guide/mongodb-device-registry-config/#service-configuration">MongoDB based Device Registry configuration</a>.</p>
 
 <h2 id="managing-tenants">Managing Tenants</h2>
 
-<p>The following sections describe the resources representing the operations of the Tenant API and how they can be used to manage tenants.
-Please refer to the <a href="/hono/docs/api/management/">Device Registry HTTP API</a> for the specific elements that are explained in detail there.</p>
+<p>Please refer to the <a href="/hono/docs/api/management/#tenants">Device Registry Management API</a> for information about managing tenants.</p>
 
-<h3 id="add-a-tenant">Add a Tenant</h3>
+<h2 id="managing-devices">Managing Devices</h2>
 
-<ul>
-<li>URI: <code>/v1/tenants/${tenantId}</code></li>
-<li>Method: <code>POST</code></li>
-<li>Request Headers:
-
-<ul>
-<li>(required) <code>Content-Type</code>: <code>application/json</code> (no other type supported)</li>
-</ul></li>
-<li>Request Body:
-
-<ul>
-<li>(Optional) A JSON object as specified by <a href="/hono/docs/api/management/">Tenant schema</a> of the HTTP API specification.</li>
-</ul></li>
-<li>Status Codes:
-
-<ul>
-<li>201 (Created): Tenant has been added successfully under the resource indicated by <code>Location</code> header.</li>
-<li>400 (Bad Request): The tenant has not been created because the request was malformed, e .g. because the payload was malformed. The response body may contain hints regarding the cause of the problem.</li>
-<li>409 (Conflict): A tenant with the given <code>tenantId</code> already exists. The request has not been processed.</li>
-</ul></li>
-<li>Response Headers:
-
-<ul>
-<li><code>Location</code>: The URI under which the newly created resource can be accessed.</li>
-<li><code>ETag</code>: Version of the resource</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<p>The following commands add some tenants with different adapter configurations:</p>
-
-<p>Add a tenant that has all adapters set to enabled:</p>
-
-<pre><code class="language-sh">curl -i -X POST http://localhost:28080/v1/tenants/tenantAllAdapters
-
-HTTP/1.1 201 Created
-ETag: becc93d7-ab0f-48ec-ad26-debdf339cbf4
-Location: /v1/tenants/tenantAllAdapters
-Content-Type: application/json; charset=utf-8
-
-{&quot;id&quot;: &quot;tenantAllAdapters&quot;}
-</code></pre>
-
-<p>Add a tenant that can only use the MQTT adapter:</p>
-
-<pre><code class="language-sh">curl -i -X POST -H 'Content-Type: application/json' --data-binary '{
-    &quot;adapters&quot;: [ {
-        &quot;type&quot;: &quot;hono-mqtt&quot;,
-        &quot;enabled&quot;: true
-        } ]
-  }' http://localhost:28080/v1/tenants/tenantMqttAdapter
-
-HTTP/1.1 201 Created
-ETag: becc93d7-ab0f-48ec-ad26-debdf339cbf4
-Location:  /v1/tenants/tenantMqttAdapter
-Content-Type: application/json; charset=utf-8
-
-{&quot;id&quot;: &quot;tenantMqttAdapter&quot;}
-</code></pre>
-
-<h3 id="get-configuration-details-of-a-tenant">Get configuration details of a Tenant</h3>
-
-<ul>
-<li>URI: <code>/v1/tenants/${tenantId}</code></li>
-<li>Method: <code>GET</code></li>
-<li>Status Codes:
-
-<ul>
-<li>200 (OK): A tenant with the given identifier has been found. The response body contains the tenant data as specified by <a href="/hono/docs/api/management/">Tenant schema</a> of the HTTP API specification.</li>
-<li>404 (Not Found): No tenant with the given identifier is registered.</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<p>The following command retrieves the details for the tenant <code>tenantMqttAdapter</code>:</p>
-
-<pre><code class="language-sh">curl -i http://localhost:28080/v1/tenants/tenantMqttAdapter
-
-HTTP/1.1 200 OK
-ETag: becc93d7-ab0f-48ec-ad26-debdf339cbf4
-Content-Type: application/json; charset=utf-8
-
-{
-     &quot;enabled&quot;: true,
-     &quot;adapters&quot;: [ {
-         &quot;type&quot;: &quot;hono-mqtt&quot;,
-         &quot;enabled&quot;: true
-     } ]
-}
-</code></pre>
-
-<p><strong>NB</strong> A tenant can be created without specifying a tenant identifier. The device registry will generate a tenant ID:</p>
-
-<pre><code class="language-sh">curl -i  -X POST http://localhost:28080/v1/tenants/
-
-HTTP/1.1 201 Created
-Etag: edc93899-7838-4dd1-93c8-839748c2fa42
-location: /v1/tenants/0b2df55f-1a02-43f7-a1c0-f3dbd25041e0
-content-type: application/json; charset=utf-8
-content-length: 45
-
-{&quot;id&quot;:&quot;0b2df55f-1a02-43f7-a1c0-f3dbd25041e0&quot;}
-</code></pre>
-
-<h3 id="update-tenant">Update Tenant</h3>
-
-<ul>
-<li>URI: <code>/v1/tenants/${tenantId}</code></li>
-<li>Method: <code>PUT</code></li>
-<li>Request Headers:
-
-<ul>
-<li>(required) <code>Content-Type</code>: <code>application/json</code> (no other type supported)</li>
-</ul></li>
-<li>Request Body:
-
-<ul>
-<li>(required) A JSON object as specified by <a href="/hono/docs/api/management/">Tenant schema</a> of the HTTP API specification.</li>
-</ul></li>
-<li>Status Codes:
-
-<ul>
-<li>204 (No Content): The tenant has been updated successfully.</li>
-<li>400 (Bad Request): The tenant has not been updated because the request was malformed, e .g. because the payload was malformed. The response body may contain hints regarding the cause of the problem.</li>
-<li>404 (Not Found): The request could not be processed because no tenant with the given identifier exists.</li>
-</ul></li>
-</ul>
-
-<p>This resource can be used to change the configuration of a particular tenant.</p>
-
-<p><strong>Example</strong></p>
-
-<p>The following command disables the MQTT adapter for devices that belong to the tenant <code>tenantMqttAdapter</code>:</p>
-
-<pre><code class="language-sh">curl -i -X PUT -H 'Content-Type: application/json' --data-binary '{
-      &quot;adapters&quot;: [ {
-          &quot;type&quot;: &quot;hono-mqtt&quot;,
-          &quot;enabled&quot;: true
-          } ]
-  }' http://localhost:28080/v1/tenants/tenantMqttAdapter
-
-HTTP/1.1 204 No Content
-ETag: 8919c736-30aa-40ce-a45a-830b90c4cd42
-Content-Length: 0
-</code></pre>
-
-<h3 id="delete-tenant">Delete Tenant</h3>
-
-<ul>
-<li>URI: <code>/v1/tenants/${tenantId}</code></li>
-<li>Method: <code>DELETE</code></li>
-<li>Status Codes:
-
-<ul>
-<li>204 (No Content): The tenant with the given identifier has been deleted.</li>
-<li>404 (Not Found): The request could not be processed because no tenant with the given identifier exists.</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<pre><code class="language-sh">curl -i -X DELETE http://localhost:28080/v1/tenants/tenantMqttAdapter
-
-HTTP/1.1 204 No Content
-Content-Length: 0
-</code></pre>
-
-<h2 id="managing-device-registration-information">Managing Device Registration Information</h2>
-
-<p>The following sections describe the resources representing the operations of the <a href="/hono/docs/api/device-registration/">Device Registration API</a> and how they can be used to manage device registration information.
-Please refer to the <a href="/hono/docs/api/management/">Device Registry HTTP API</a> for the specific elements that are explained in detail there.</p>
-
-<h3 id="register-device">Register Device</h3>
-
-<ul>
-<li>URI: <code>/v1/devices/${tenantId}/${deviceId}</code></li>
-<li>Method: <code>POST</code></li>
-<li>Headers:
-
-<ul>
-<li>(required) <code>Content-Type</code>: <code>application/json</code></li>
-</ul></li>
-<li>Request Body:
-
-<ul>
-<li>(Optional) A JSON object as specified by <a href="/hono/docs/api/management/">Device schema</a> of the HTTP API specification.</li>
-</ul></li>
-<li>Status Codes:
-
-<ul>
-<li>201 (Created): Device has been registered successfully under resource indicated by <code>Location</code> header.</li>
-<li>400 (Bad Request): Device has not been registered because the request was malformed, e .g. a required header is missing (the body may contain hints regarding the problem).</li>
-<li>409 (Conflict): There already exists a device with the given ID. The request has not been processed.</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<p>The following command registers a device with ID <code>4711</code> for tenant <code>DEFAULT_TENANT</code></p>
-
-<pre><code class="language-sh">curl -i -X POST -H 'Content-Type: application/json' --data-binary '{
-    &quot;ext&quot;: {
-        &quot;ep&quot;: &quot;IMEI4711&quot;
-    }
-}' http://localhost:28080/v1/devices/DEFAULT_TENANT/4711
-</code></pre>
-
-<p>The response will contain a <code>Location</code> header containing the resource path created for the device. In this example it will look
-like this:</p>
-
-<pre><code class="language-sh">HTTP/1.1 201 Created
-Location: /v1/devices/DEFAULT_TENANT/4711
-ETag: becc93d7-ab0f-48ec-ad26-debdf339cbf4
-Content-Type: application/json; charset=utf-8
-
-{&quot;id&quot;: &quot;4711&quot;}
-</code></pre>
-
-<p><strong>NB</strong> A device can be created without specifying a device identifier. The device registry will generate a device identifier:</p>
-
-<pre><code class="language-sh">curl -i -X POST http://localhost:28080/v1/devices/DEFAULT_TENANT
-
-HTTP/1.1 201 Created
-Etag: 0d615bcd-0825-44d9-9ef5-54a7b12165d8
-location: /v1/devices/DEFAULT_TENANT/98d25103-d49d-44b0-bdd0-0de84743c522
-content-type: application/json; charset=utf-8
-content-length: 45
-
-{&quot;id&quot;:&quot;98d25103-d49d-44b0-bdd0-0de84743c522&quot;}
-</code></pre>
-
-<h3 id="read-device">Read Device</h3>
-
-<ul>
-<li>URI: <code>/v1/devices/${tenantId}/${deviceId}</code></li>
-<li>Method: <code>GET</code></li>
-<li>Status Codes:
-
-<ul>
-<li>200 (OK): A device with the given identifier has been found. The response body contains the registration information as specified by <a href="/hono/docs/api/management/">Device schema</a> of the HTTP API specification.</li>
-<li>404 (Not Found): No device with the given identifier is registered for the given tenant.</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<p>The following command retrieves registration data for device <code>4711</code>:</p>
-
-<pre><code class="language-sh">curl -i http://localhost:28080/v1/devices/DEFAULT_TENANT/4711
-
-HTTP/1.1 200 OK
-Content-Type: application/json; charset=utf-8
-
-{
-    &quot;enabled&quot;: true,
-    &quot;ext&quot;: {
-        &quot;ep&quot;: &quot;IMEI4711&quot;
-    }
-}
-</code></pre>
-
-<h3 id="update-device">Update Device</h3>
-
-<ul>
-<li>URI: <code>/devices/v1/${tenantId}/${deviceId}</code></li>
-<li>Method: <code>PUT</code></li>
-<li>Headers:
-
-<ul>
-<li>(required) <code>Content-Type</code>: <code>application/json</code></li>
-</ul></li>
-<li>Parameters (encoded as a JSON object in the request body):</li>
-<li>Request Body:
-
-<ul>
-<li>(required) A JSON object as specified by <a href="/hono/docs/api/management/">Device schema</a> of the HTTP API specification. All existing registration information will be replaced by the data provided in the object.</li>
-</ul></li>
-<li>Status Codes:
-
-<ul>
-<li>204 (No Content): Device registration data has been updated.</li>
-<li>400 (Bad Request): Device registration has not been updated because the request was malformed, e .g. a required header is missing (the body may contain hints regarding the problem).</li>
-<li>404 (Not Found): No device with the given identifier is registered for the given tenant.</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<pre><code class="language-sh">curl -i -X PUT -H 'Content-Type: application/json' --data-binary '{
-    &quot;ext&quot;: {
-        &quot;ep&quot;: &quot;IMEI4711&quot;,
-        &quot;psk-id&quot;: &quot;psk4711&quot;
-    }
-}' http://localhost:28080/v1/devices/DEFAULT_TENANT/4711
-
-HTTP/1.1 204 No Content
-Content-Length: 0
-</code></pre>
-
-<h3 id="delete-device">Delete Device</h3>
-
-<ul>
-<li>URI: <code>/v1/devices/${tenantId}/${deviceId}</code></li>
-<li>Method: <code>DELETE</code></li>
-<li>Status Codes:
-
-<ul>
-<li>204 (No Content): Device registration has been deleted.</li>
-<li>404 (Not Found): No device with the given identifier is registered for the given tenant.</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<pre><code class="language-sh">curl -i -X DELETE http://localhost:28080/v1/devices/DEFAULT_TENANT/4711
-
-HTTP/1.1 204 No Content
-Content-Length: 0
-</code></pre>
+<p>Please refer to the <a href="/hono/docs/api/management/#devices">Device Registry Management API</a> for information about managing devices.</p>
 
 <h2 id="managing-credentials">Managing Credentials</h2>
 
-<p>The following sections describe the resources representing the operations of the Credentials API and how they can be used to manage credentials for devices.
-Please refer to the <a href="/hono/docs/api/management/">Device Registry HTTP API</a> for the specific elements that are explained in detail there.</p>
+<p>Please refer to the <a href="/hono/docs/api/management/#credentials">Device Registry Management API</a> for information about managing credentials.</p>
 
-<h3 id="update-credentials-for-a-device">Update Credentials for a Device</h3>
-
-<ul>
-<li>URI: <code>/v1/credentials/${tenantId}/${deviceId}</code></li>
-<li>Method: <code>PUT</code></li>
-<li>Request Headers:
-
-<ul>
-<li>(required) <code>Content-Type</code>: <code>application/json</code> (no other type supported)</li>
-</ul></li>
-<li>Request Body:
-
-<ul>
-<li>(required) A JSON object as specified by <a href="/hono/docs/api/management/">Credentials schema</a> of the HTTP API specification.</li>
-</ul></li>
-<li>Status Codes:
-
-<ul>
-<li>204 (No Content): Credentials have been updated successfully.</li>
-<li>400 (Bad Request): The credentials have not been added because the request was malformed, e .g. because the payload did not contain required values. The response body may contain hints regarding the cause of the problem.</li>
-</ul></li>
-<li>Response Headers:
-
-<ul>
-<li><code>ETag</code>: Version of the resource</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<p>The following command adds some <code>hashed-password</code> credentials from a given plain text password for device <code>4710</code> using authentication identifier <code>sensor10</code>:</p>
-
-<pre><code class="language-sh">curl -i -X PUT -H 'Content-Type: application/json' --data-binary '[{
-  &quot;type&quot;: &quot;hashed-password&quot;,
-  &quot;auth-id&quot;: &quot;sensor10&quot;,
-  &quot;secrets&quot;: [{
-      &quot;pwd-plain&quot;: &quot;mylittlesecret&quot;
-  }]
-}]' http://localhost:28080/v1/credentials/DEFAULT_TENANT/4710
-  
-HTTP/1.1 204 No Content
-ETag: becc93d7-ab0f-48ec-ad26-debdf339cbf4x
-</code></pre>
-
-<p>This uses a convenient option which lets the Device Registry do the hashing of the password. The following command retrieves the credentials that are stored by the Device Registry as a result of the command above:</p>
-
-<pre><code class="language-sh">curl -i http://localhost:28080/v1/credentials/DEFAULT_TENANT/4710
-
-HTTP/1.1 200 OK
-Content-Type: application/json; charset=utf-8
-ETag: becc93d7-ab0f-48ec-ad26-debdf339cbf4x
-
-[{
-  &quot;type&quot;: &quot;hashed-password&quot;,
-  &quot;auth-id&quot;: &quot;sensor10&quot;,
-  &quot;enabled&quot;: true,
-  &quot;secrets&quot;: [
-    {
-      &quot;id&quot;: &quot;349556ea-4902-47c7-beb0-1009ab693fb4&quot;
-    }
-  ]
-}]
-</code></pre>
-
-<p>The above result does not contain <code>pwd_hash</code> and <code>hash_function</code> of the secret, as these values are confidential.</p>
-
-<p>The following commands set some <code>hashed-password</code> credentials for device <code>4720</code> using authentication identifier <code>sensor20</code>:</p>
-
-<pre><code class="language-sh">curl -i -X PUT -H 'Content-Type: application/json' --data-binary '[{
-    &quot;type&quot;: &quot;hashed-password&quot;,
-    &quot;auth-id&quot;: &quot;sensor20&quot;,
-    &quot;secrets&quot;: [{
-        &quot;pwd-plain&quot;: &quot;mylittlesecret&quot;
-    }]
-  }]' http://localhost:28080/v1/credentials/DEFAULT_TENANT/4720
-
-HTTP/1.1 204 No Content
-ETag: 02c99fb5-af8c-409f-8520-b405e224b27f
-</code></pre>
-
-<p>The following command adds an expiration date to the <code>hashed-password</code> credentials for authentication identifier <code>sensor20</code>:</p>
-
-<pre><code class="language-sh">curl -i -X PUT -H 'Content-Type: application/json' --data-binary '{
-    &quot;device-id&quot;: &quot;4720&quot;,
-    &quot;type&quot;: &quot;hashed-password&quot;,
-    &quot;auth-id&quot;: &quot;sensor20&quot;,
-    &quot;secrets&quot;: [{
-        &quot;pwd-plain&quot;: &quot;mylittlesecret&quot;,
-        &quot;not-after&quot;: &quot;2018-01-01T00:00:00+01:00&quot;
-    }]
-}' http://localhost:28080/v1/credentials/DEFAULT_TENANT/4720
-
-HTTP/1.1 204 No Content
-ETag: becc93d7-ab0f-48ec-ad26-debdf339cbf4x
-</code></pre>
-
-<p>Multiple credentials of different type can be registered for the same authentication identifier.
-The following commands add <code>psk</code> credentials for the same device <code>4720</code> using authentication identifier <code>sensor20</code>:</p>
-
-<pre><code class="language-sh">SHARED_KEY=$(echo -n &quot;TheSharedKey&quot; | base64 -w 0)
-curl -i -X PUT -H 'Content-Type: application/json' --data-binary '[
-{
-    &quot;type&quot;: &quot;hashed-password&quot;,
-    &quot;auth-id&quot;: &quot;sensor20&quot;,
-    &quot;secrets&quot;: [{
-        &quot;pwd-plain&quot;: &quot;mylittlesecret&quot;
-    }]
-},
-{
-   &quot;device-id&quot;: &quot;4720&quot;,
-   &quot;type&quot;: &quot;psk&quot;,
-   &quot;auth-id&quot;: &quot;sensor20&quot;,
-   &quot;secrets&quot;: [{
-     &quot;key&quot;: &quot;'$SHARED_KEY'&quot;
-     }]
-  }]' http://localhost:28080/v1/credentials/DEFAULT_TENANT/4720
-
-HTTP/1.1 204 No Content
-ETag: 122c971a-505a-4336-8f7d-640360e909bc
-</code></pre>
-
-<p>The following command deletes all credentials for device <code>4710</code>:</p>
-
-<pre><code class="language-sh">curl -i -X PUT -H 'Content-Type: application/json' --data-binary '[]' http://localhost:28080/v1/credentials/DEFAULT_TENANT/4710
-
-HTTP/1.1 204 No Content
-ETag: d383ba4d-1853-4d03-b322-b7ff5af05ae2
-</code></pre>
-
-<h3 id="get-all-credentials-for-a-device">Get all Credentials for a Device</h3>
-
-<ul>
-<li>URI: <code>/v1/credentials/${tenantId}/${deviceId}</code></li>
-<li>Method: <code>GET</code></li>
-<li>Status Codes:
-
-<ul>
-<li>200 (OK): Credentials for the device have been found, body contains the credentials. The response body contains the registration information as specified by <a href="/hono/docs/api/management/">Credentials schema</a> of the HTTP API specification.</li>
-<li>404 (Not Found): No credentials for the device are registered.</li>
-</ul></li>
-</ul>
-
-<p><strong>Example</strong></p>
-
-<p>The following command retrieves credentials metadata for device <code>4720</code>:</p>
-
-<pre><code class="language-sh">curl -i http://localhost:28080/v1/credentials/DEFAULT_TENANT/4720
-
-HTTP/1.1 200 OK
-Content-Type: application/json; charset=utf-8
-ETag: f3449b77-2c84-4b09-8d04-2b305876e0cb
-
-{[
-    {
-        &quot;auth-id&quot;: &quot;sensor20&quot;,
-        &quot;enabled&quot;: true,
-        &quot;secrets&quot;: [
-            {
-                &quot;id&quot;: &quot;d383ba4d-1853-4d03-b322-b7ff5af05ae2&quot;
-                &quot;not-after&quot;: &quot;2020-02-1T00:00:00+01:00&quot;
-            },
-            {
-                &quot;id&quot;: &quot;46810d5c-133e-4c1c-994d-ed7745516b8e&quot;
-                &quot;not-before&quot;: &quot;2020-01-01T00:00:00+01:00&quot;
-            }
-        ],
-        &quot;type&quot;: &quot;hashed-password&quot;
-    },
-    {
-        &quot;auth-id&quot;: &quot;sensor20&quot;,
-        &quot;enabled&quot;: true,
-        &quot;secrets&quot;: [
-            {
-                &quot;key&quot;: &quot;VGhlU2hhcmVkS2V5&quot;
-            }
-        ],
-        &quot;type&quot;: &quot;psk&quot;
-    }
-]}
-</code></pre>
 
 <footer class=" footline" >
 	
@@ -2322,6 +1845,22 @@
             
         
                     
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
             
         
                     
@@ -2530,6 +2069,38 @@
             
         
                     
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
             
         
                     
@@ -2932,20 +2503,20 @@
     <div style="left: -1000px; overflow: scroll; position: absolute; top: -1000px; border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;">
       <div style="border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;"></div>
     </div>
-    <script src="/hono/docs/js/clipboard.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595208214"></script>
-    <script src="/hono/docs/js/jquery.sticky.js?1595208214"></script>
-    <script src="/hono/docs/js/featherlight.min.js?1595208214"></script>
-    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595208214"></script>
-    <script src="/hono/docs/js/highlight.pack.js?1595208214"></script>
+    <script src="/hono/docs/js/clipboard.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595294628"></script>
+    <script src="/hono/docs/js/jquery.sticky.js?1595294628"></script>
+    <script src="/hono/docs/js/featherlight.min.js?1595294628"></script>
+    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595294628"></script>
+    <script src="/hono/docs/js/highlight.pack.js?1595294628"></script>
     <script>hljs.initHighlightingOnLoad();</script>
-    <script src="/hono/docs/js/modernizr.custom.71422.js?1595208214"></script>
-    <script src="/hono/docs/js/learn.js?1595208214"></script>
-    <script src="/hono/docs/js/hugo-learn.js?1595208214"></script>
+    <script src="/hono/docs/js/modernizr.custom.71422.js?1595294628"></script>
+    <script src="/hono/docs/js/learn.js?1595294628"></script>
+    <script src="/hono/docs/js/hugo-learn.js?1595294628"></script>
 
-    <link href="/hono/docs/mermaid/mermaid.css?1595208214" type="text/css" rel="stylesheet" />
-    <script src="/hono/docs/mermaid/mermaid.js?1595208214"></script>
+    <link href="/hono/docs/mermaid/mermaid.css?1595294628" type="text/css" rel="stylesheet" />
+    <script src="/hono/docs/mermaid/mermaid.js?1595294628"></script>
     <script>
         mermaid.initialize({ startOnLoad: true });
     </script>
diff --git a/docs/user-guide/mqtt-adapter/index.html b/docs/user-guide/mqtt-adapter/index.html
index fdac290..627559d 100644
--- a/docs/user-guide/mqtt-adapter/index.html
+++ b/docs/user-guide/mqtt-adapter/index.html
@@ -21,19 +21,19 @@
     <title>MQTT Adapter :: Eclipse Hono&trade;</title>
 
     
-    <link href="/hono/docs/css/nucleus.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/fontawesome-all.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hybrid.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/featherlight.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/auto-complete.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/theme.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hugo-theme.css?1595208214" rel="stylesheet">
+    <link href="/hono/docs/css/nucleus.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/fontawesome-all.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hybrid.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/featherlight.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/auto-complete.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/theme.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hugo-theme.css?1595294628" rel="stylesheet">
     
-      <link href="/hono/docs/css/theme-hono.css?1595208214" rel="stylesheet">
+      <link href="/hono/docs/css/theme-hono.css?1595294628" rel="stylesheet">
     
 
-    <script src="/hono/docs/js/jquery-2.x.min.js?1595208214"></script>
+    <script src="/hono/docs/js/jquery-2.x.min.js?1595294628"></script>
 
     <style type="text/css">
       :root #header + #content > #left > #rlblock_left{
@@ -83,14 +83,14 @@
     <span data-search-clear=""><i class="fas fa-times"></i></span>
 </div>
 
-<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595208214"></script>
-<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595294628"></script>
+<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595294628"></script>
 <script type="text/javascript">
     
         var baseurl = "https:\/\/www.eclipse.org\/hono\/docs\/";
     
 </script>
-<script type="text/javascript" src="/hono/docs/js/search.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/search.js?1595294628"></script>
 
     
   </div>
@@ -315,9 +315,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/user-guide/device-registry/" title="Device Registry" class="dd-item ">
-        <a href="/hono/docs/user-guide/device-registry/">
-        Device Registry
+      <li data-nav-id="/hono/docs/user-guide/mongodb-based-device-registry/" title="MongoDB Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/mongodb-based-device-registry/">
+        MongoDB Based Device Registry
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/user-guide/file-based-device-registry/" title="File Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/file-based-device-registry/">
+        File Based Device Registry
         
         </a>
     </li>
@@ -537,9 +556,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/device-registry-config/" title="Device Registry Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/device-registry-config/">
-        Device Registry Configuration
+      <li data-nav-id="/hono/docs/admin-guide/mongodb-device-registry-config/" title="MongoDB Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mongodb-device-registry-config/">
+        MongoDB Based Device Registry Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/admin-guide/file-based-device-registry-config/" title="File Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/file-based-device-registry-config/">
+        File Based Device Registry Configuration
         
         </a>
     </li>
@@ -594,6 +632,25 @@
  
   
     
+      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
+        MQTT Adapter Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
       <li data-nav-id="/hono/docs/admin-guide/amqp-adapter-config/" title="AMQP Adapter Configuration" class="dd-item ">
         <a href="/hono/docs/admin-guide/amqp-adapter-config/">
         AMQP Adapter Configuration
@@ -613,9 +670,9 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
-        MQTT Adapter Configuration
+      <li data-nav-id="/hono/docs/admin-guide/coap-adapter-config/" title="CoAP Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/coap-adapter-config/">
+        CoAP Adapter Configuration
         
         </a>
     </li>
@@ -1277,7 +1334,27 @@
                   
                     
                     
-                      <option id="stable" value="/hono/docs/user-guide/mqtt-adapter/" selected>stable (1.2)</option>
+                      <option id="stable" value="/hono/docs/user-guide/mqtt-adapter/" selected>stable (1.3)</option>
+                    
+                  
+              
+                  
+              
+                  
+              
+                  
+              
+                  
+              
+          
+              
+              
+                  
+              
+                  
+                    
+                    
+                      <option id="1.2" value="/hono/docs/1.2/user-guide/mqtt-adapter/">1.2</option>
                     
                   
               
@@ -1293,6 +1370,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="1.1" value="/hono/docs/1.1/user-guide/mqtt-adapter/">1.1</option>
@@ -1311,6 +1390,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="1.0" value="/hono/docs/1.0/user-guide/mqtt-adapter/">1.0</option>
@@ -1329,6 +1410,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="dev" value="/hono/docs/dev/user-guide/mqtt-adapter/">dev</option>
@@ -1456,7 +1539,7 @@
 <li><a href="#connection-duration-limits">Connection Duration Limits</a></li>
 <li><a href="#message-limits">Message Limits</a></li>
 </ul></li>
-<li><a href="#connection-event">Connection Event</a></li>
+<li><a href="#connection-events">Connection Events</a></li>
 <li><a href="#publishing-telemetry-data">Publishing Telemetry Data</a></li>
 <li><a href="#publish-telemetry-data-authenticated-device">Publish Telemetry Data (authenticated Device)</a></li>
 <li><a href="#publish-telemetry-data-unauthenticated-device">Publish Telemetry Data (unauthenticated Device)</a></li>
@@ -1474,6 +1557,7 @@
 <li><a href="#sending-a-response-to-a-command-unauthenticated-device">Sending a Response to a Command (unauthenticated Device)</a></li>
 <li><a href="#sending-a-response-to-a-command-authenticated-gateway">Sending a Response to a Command (authenticated Gateway)</a></li>
 </ul></li>
+<li><a href="#custom-message-mapping">Custom Message Mapping</a></li>
 <li><a href="#downstream-meta-data">Downstream Meta Data</a>
 <ul>
 <li><a href="#event-message-time-to-live">Event Message Time-to-live</a></li>
@@ -1513,28 +1597,39 @@
 
 <h2 id="authentication">Authentication</h2>
 
-<p>The MQTT adapter by default requires clients (devices or gateway components) to authenticate during connection establishment. The adapter supports both the authentication based on the username/password provided in an MQTT CONNECT packet as well as client certificate based authentication as part of a TLS handshake for that purpose.</p>
+<p>The MQTT adapter by default requires clients (devices or gateway components) to authenticate during connection establishment.
+The adapter supports both the authentication based on the username/password provided in an MQTT CONNECT packet as well as client
+certificate based authentication as part of a TLS handshake for that purpose.</p>
 
 <p>The adapter tries to authenticate the device using these mechanisms in the following order</p>
 
 <h3 id="client-certificate">Client Certificate</h3>
 
-<p>When a device uses a client certificate for authentication during the TLS handshake, the adapter tries to determine the tenant that the device belongs to based on the <em>issuer DN</em> contained in the certificate.
-In order for the lookup to succeed, the tenant&rsquo;s trust anchor needs to be configured by means of registering the <a href="/hono/docs/api/tenant/#tenant-information-format">trusted certificate authority</a>.
-The device&rsquo;s client certificate will then be validated using the registered trust anchor, thus implicitly establishing the tenant that the device belongs to.
-In a second step, the adapter uses the Credentials API&rsquo;s <em>get</em> operation to retrieve the credentials on record, including the client certificate&rsquo;s <em>subject DN</em> as the <em>auth-id</em>, <code>x509-cert</code> as the <em>type</em> of secret and the MQTT client identifier as <em>client-id</em> in the request payload.</p>
+<p>When a device uses a client certificate for authentication during the TLS handshake, the adapter tries to determine the tenant
+that the device belongs to based on the <em>issuer DN</em> contained in the certificate.
+In order for the lookup to succeed, the tenant&rsquo;s trust anchor needs to be configured by means of registering the
+<a href="/hono/docs/api/tenant/#tenant-information-format">trusted certificate authority</a>. The device&rsquo;s client certificate will then be
+validated using the registered trust anchor, thus implicitly establishing the tenant that the device belongs to.
+In a second step, the adapter uses the Credentials API&rsquo;s <em>get</em> operation to retrieve the credentials on record, including the client
+certificate&rsquo;s <em>subject DN</em> as the <em>auth-id</em>, <code>x509-cert</code> as the <em>type</em> of secret and the MQTT client identifier as <em>client-id</em> in the
+request payload.</p>
 
 <p><strong>NB</strong> The adapter needs to be <a href="/hono/docs/admin-guide/secure_communication/#mqtt-adapter">configured for TLS</a> in order to support this mechanism.</p>
 
 <h3 id="username-password">Username/Password</h3>
 
-<p>When a device wants to authenticate using this mechanism, it needs to provide a <em>username</em> and a <em>password</em> in the MQTT <em>CONNECT</em> packet it sends in order to initiate the connection. The <em>username</em> must have the form <em>auth-id@tenant</em>, e.g. <code>sensor1@DEFAULT_TENANT</code>.
-The adapter verifies the credentials provided by the client against the credentials that the <a href="/hono/docs/admin-guide/common-config/#credentials-service-connection-configuration">configured Credentials service</a> has on record for the client.
-The adapter uses the Credentials API&rsquo;s <em>get</em> operation to retrieve the credentials on record, including the <em>tenant</em> and <em>auth-id</em> provided by the client in the <em>username</em>, <code>hashed-password</code> as the <em>type</em> of secret and the MQTT client identifier as <em>client-id</em> in the request payload.</p>
+<p>When a device wants to authenticate using this mechanism, it needs to provide a <em>username</em> and a <em>password</em> in the MQTT <em>CONNECT</em> packet
+it sends in order to initiate the connection. The <em>username</em> must have the form <em>auth-id@tenant</em>, e.g. <code>sensor1@DEFAULT_TENANT</code>.
+The adapter verifies the credentials provided by the client against the credentials that the
+<a href="/hono/docs/admin-guide/common-config/#credentials-service-connection-configuration">configured Credentials service</a> has on record for the client.
+The adapter uses the Credentials API&rsquo;s <em>get</em> operation to retrieve the credentials on record, including the <em>tenant</em> and <em>auth-id</em> provided
+by the client in the <em>username</em>, <code>hashed-password</code> as the <em>type</em> of secret and the MQTT client identifier as <em>client-id</em> in the request payload.</p>
 
-<p>The examples below refer to devices <code>4711</code> and <code>gw-1</code> of tenant <code>DEFAULT_TENANT</code> using <em>auth-ids</em> <code>sensor1</code> and <code>gw1</code> and corresponding passwords. The example deployment as described in the <a href="/hono/docs/deployment/">Deployment Guides</a> comes pre-configured with the corresponding entities in its device registry component.</p>
+<p>The examples below refer to devices <code>4711</code> and <code>gw-1</code> of tenant <code>DEFAULT_TENANT</code> using <em>auth-ids</em> <code>sensor1</code> and <code>gw1</code> and corresponding passwords.
+The example deployment as described in the <a href="/hono/docs/deployment/">Deployment Guides</a> comes pre-configured with the corresponding entities in its device registry component.</p>
 
-<p><strong>NB</strong> There is a subtle difference between the <em>device identifier</em> (<em>device-id</em>) and the <em>auth-id</em> a device uses for authentication. See <a href="/hono/docs/concepts/device-identity/">Device Identity</a> for a discussion of the concepts.</p>
+<p><strong>NB</strong> There is a subtle difference between the <em>device identifier</em> (<em>device-id</em>) and the <em>auth-id</em> a device uses for authentication.
+See <a href="/hono/docs/concepts/device-identity/">Device Identity</a> for a discussion of the concepts.</p>
 
 <h2 id="resource-limit-checks">Resource Limit Checks</h2>
 
@@ -1567,9 +1662,13 @@
 
 <p>if the <a href="/hono/docs/concepts/resource-limits/">message limit</a> that has been configured for the device’s tenant is exceeded.</p>
 
-<h2 id="connection-event">Connection Event</h2>
+<h2 id="connection-events">Connection Events</h2>
 
-<p>The MQTT Adapter can send a <a href="/hono/docs/api/event/#connection-event">Connection Event</a> once the connection with a device has been successfully established or ended. Note that this requires the <a href="/hono/docs/admin-guide/mqtt-adapter-config/#service-configuration"><code>HONO_CONNECTION_EVENTS_PRODUCER</code></a> configuration property to be explicitly set to <code>events</code>.</p>
+<p>The adapter can emit <a href="/hono/docs/api/event/#connection-event">Connection Events</a> for client connections being established and/or terminated.
+Please refer to the <a href="/hono/docs/admin-guide/common-config/#connection-event-producer-configuration">common configuration options</a>
+for details regarding how to enable this behavior.</p>
+
+<p>The adapter includes the <em>client identifier</em> from the client&rsquo;s MQTT CONNECT packet as the Connection Event&rsquo;s <em>remote-id</em>.</p>
 
 <h2 id="publishing-telemetry-data">Publishing Telemetry Data</h2>
 
@@ -1852,7 +1951,7 @@
 
 <h3 id="receiving-commands-authenticated-gateway">Receiving Commands (authenticated Gateway)</h3>
 
-<p><em>Gateway</em> components can receive commands for devices which do not connect to a protocol adapter directly but instead are connected to the gateway, e.g. using some low-bandwidth radio based technology like <a href="https://www.sigfox.com">SigFox</a> or <a href="https://lora-alliance.org/">LoRa</a>. Corresponding devices have to be configured so that they can be used with a gateway. See <a href="/hono/docs/admin-guide/device-registry-config/#configuring-gateway-devices">Configuring Gateway Devices</a> for details.</p>
+<p><em>Gateway</em> components can receive commands for devices which do not connect to a protocol adapter directly but instead are connected to the gateway, e.g. using some low-bandwidth radio based technology like <a href="https://www.sigfox.com">SigFox</a> or <a href="https://lora-alliance.org/">LoRa</a>. Corresponding devices have to be configured so that they can be used with a gateway. See <a href="/hono/docs/admin-guide/file-based-device-registry-config/#configuring-gateway-devices">Configuring Gateway Devices</a> for details.</p>
 
 <p>An authenticated gateway MUST use the topic filter <code>command//+/req/#</code> to subscribe to commands for all devices in whose behalf it acts.</p>
 
@@ -1937,6 +2036,45 @@
 <pre><code class="language-sh">mosquitto_pub -u 'gw@DEFAULT_TENANT' -P gw-secret -t command//4711/res/1010f8ab0b53-bd96-4d99-9d9c-56b868474a6a/200 -m '{&quot;lumen&quot;: 200}'
 </code></pre>
 
+<h2 id="custom-message-mapping">Custom Message Mapping</h2>
+
+<p>This protocol adapter supports transformation of messages that have been uploaded by devices before they get forwarded to downstream consumers.</p>
+
+<div class="alert alert-notice">
+    <h4 class="alert-heading"><i class="fas fa-info-circle"></i> Experimental</h4>
+    <div>This is an experimental feature. The names of the configuration properties, potential values and the overall functionality are therefore
+subject to change without prior notice.</div>
+</div>
+
+
+<p>This feature is useful in scenarios where devices are connected to the adapter via a gateway but the gateway is not able to include
+the device ID in the topic that the gateway publishes data to. The gateway will use the plain <code>telemetry</code> or <code>event</code> topics in this case.
+The message payload will usually contain the identifier of the device that the data originates from.</p>
+
+<p>The same functionality can also be used to transform the payload of messages uploaded by a device. This can be used for example to
+transform binary encoded data into a JSON document which can be consumed more easily by downstream consumers.</p>
+
+<p>The mechanism works as follows:
+1. A client uploads a message to the MQTT adapter.
+1. The adapter invokes the Device Registration service&rsquo;s <em>assert Registration</em> operation using either
+   the authenticated device&rsquo;s identifier, if the topic does not contain a device ID, or the device ID from the
+   topic.
+1. If the assertion succeeds, the adapter creates the downstream message using the original message&rsquo;s payload and
+   the asserted device ID as the origin device.
+1. If the response payload contains a value for the <em>mapper</em> property, the adapter tries to find a <em>mapper endpoint</em> configuration
+   for the given value. If a mapper endpoint with a matching name has been configured for the adapter,
+   1. the adapter sends an HTTP request to the endpoint which contains the original message&rsquo;s payload in the request body.
+   1. If the response body is not empty, it is used as the downstream message&rsquo;s payload.
+   1. If the response contains a <em>device_id</em> header and its value is different from the original device ID, then the adapter
+      invokes the <em>assert Registration</em> operation again, this time using the mapped device ID instead of the original device ID.
+      If the assertion succeeds, the adapter uses the asserted (mapped) device ID for the downstream message.
+1. The adapter forwards the downstream message.</p>
+
+<p>Please refer to the <a href="/hono/docs/api/management/#/devices/createDeviceRegistration">Device Registry Management API</a>
+for how to register a <em>mapper</em> for a device.
+Please refer to the <a href="/hono/docs/admin-guide/mqtt-adapter-config/#custom-message-mapping">MQTT Adapter Admin Guide</a>
+for how to configure custom mapper endpoints.</p>
+
 <h2 id="downstream-meta-data">Downstream Meta Data</h2>
 
 <p>The adapter includes the following meta data in messages being sent downstream:</p>
@@ -1975,14 +2113,16 @@
 
 <tr>
 <td align="left"><em>x-opt-retain</em></td>
-<td align="left">* <em>message-annotations</em></td>
+<td align="left"><em>message-annotations</em></td>
 <td align="left"><em>boolean</em></td>
 <td align="left">Contains <code>true</code> if the device has published an event or telemetry message with its <em>retain</em> flag set to <code>1</code></td>
 </tr>
 </tbody>
 </table>
 
-<p>The adapter also considers <em>defaults</em> registered for the device at either the <a href="/hono/docs/api/tenant/#tenant-information-format">tenant</a> or the <a href="/hono/docs/api/device-registration/#assert-device-registration">device level</a>. The values of the default properties are determined as follows:</p>
+<p>The adapter also considers <em>defaults</em> registered for the device at either the <a href="/hono/docs/api/tenant/#tenant-information-format">tenant</a>
+or the <a href="/hono/docs/api/device-registration/#assert-device-registration">device level</a>.
+The values of the default properties are determined as follows:</p>
 
 <ol>
 <li>If the message already contains a non-empty property of the same name, the value if unchanged.</li>
@@ -2259,6 +2399,22 @@
             
                 
                     
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
                     
                 
                 
@@ -2562,6 +2718,38 @@
             
         
                     
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
             
         
                     
@@ -2964,20 +3152,20 @@
     <div style="left: -1000px; overflow: scroll; position: absolute; top: -1000px; border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;">
       <div style="border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;"></div>
     </div>
-    <script src="/hono/docs/js/clipboard.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595208214"></script>
-    <script src="/hono/docs/js/jquery.sticky.js?1595208214"></script>
-    <script src="/hono/docs/js/featherlight.min.js?1595208214"></script>
-    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595208214"></script>
-    <script src="/hono/docs/js/highlight.pack.js?1595208214"></script>
+    <script src="/hono/docs/js/clipboard.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595294628"></script>
+    <script src="/hono/docs/js/jquery.sticky.js?1595294628"></script>
+    <script src="/hono/docs/js/featherlight.min.js?1595294628"></script>
+    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595294628"></script>
+    <script src="/hono/docs/js/highlight.pack.js?1595294628"></script>
     <script>hljs.initHighlightingOnLoad();</script>
-    <script src="/hono/docs/js/modernizr.custom.71422.js?1595208214"></script>
-    <script src="/hono/docs/js/learn.js?1595208214"></script>
-    <script src="/hono/docs/js/hugo-learn.js?1595208214"></script>
+    <script src="/hono/docs/js/modernizr.custom.71422.js?1595294628"></script>
+    <script src="/hono/docs/js/learn.js?1595294628"></script>
+    <script src="/hono/docs/js/hugo-learn.js?1595294628"></script>
 
-    <link href="/hono/docs/mermaid/mermaid.css?1595208214" type="text/css" rel="stylesheet" />
-    <script src="/hono/docs/mermaid/mermaid.js?1595208214"></script>
+    <link href="/hono/docs/mermaid/mermaid.css?1595294628" type="text/css" rel="stylesheet" />
+    <script src="/hono/docs/mermaid/mermaid.js?1595294628"></script>
     <script>
         mermaid.initialize({ startOnLoad: true });
     </script>
diff --git a/docs/user-guide/sigfox-adapter/index.html b/docs/user-guide/sigfox-adapter/index.html
index 85a6027..69fbc80 100644
--- a/docs/user-guide/sigfox-adapter/index.html
+++ b/docs/user-guide/sigfox-adapter/index.html
@@ -21,19 +21,19 @@
     <title>Sigfox Adapter :: Eclipse Hono&trade;</title>
 
     
-    <link href="/hono/docs/css/nucleus.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/fontawesome-all.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hybrid.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/featherlight.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/auto-complete.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/theme.css?1595208214" rel="stylesheet">
-    <link href="/hono/docs/css/hugo-theme.css?1595208214" rel="stylesheet">
+    <link href="/hono/docs/css/nucleus.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/fontawesome-all.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hybrid.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/featherlight.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/perfect-scrollbar.min.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/auto-complete.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/theme.css?1595294628" rel="stylesheet">
+    <link href="/hono/docs/css/hugo-theme.css?1595294628" rel="stylesheet">
     
-      <link href="/hono/docs/css/theme-hono.css?1595208214" rel="stylesheet">
+      <link href="/hono/docs/css/theme-hono.css?1595294628" rel="stylesheet">
     
 
-    <script src="/hono/docs/js/jquery-2.x.min.js?1595208214"></script>
+    <script src="/hono/docs/js/jquery-2.x.min.js?1595294628"></script>
 
     <style type="text/css">
       :root #header + #content > #left > #rlblock_left{
@@ -83,14 +83,14 @@
     <span data-search-clear=""><i class="fas fa-times"></i></span>
 </div>
 
-<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595208214"></script>
-<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/lunr.min.js?1595294628"></script>
+<script type="text/javascript" src="/hono/docs/js/auto-complete.js?1595294628"></script>
 <script type="text/javascript">
     
         var baseurl = "https:\/\/www.eclipse.org\/hono\/docs\/";
     
 </script>
-<script type="text/javascript" src="/hono/docs/js/search.js?1595208214"></script>
+<script type="text/javascript" src="/hono/docs/js/search.js?1595294628"></script>
 
     
   </div>
@@ -315,9 +315,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/user-guide/device-registry/" title="Device Registry" class="dd-item ">
-        <a href="/hono/docs/user-guide/device-registry/">
-        Device Registry
+      <li data-nav-id="/hono/docs/user-guide/mongodb-based-device-registry/" title="MongoDB Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/mongodb-based-device-registry/">
+        MongoDB Based Device Registry
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/user-guide/file-based-device-registry/" title="File Based Device Registry" class="dd-item ">
+        <a href="/hono/docs/user-guide/file-based-device-registry/">
+        File Based Device Registry
         
         </a>
     </li>
@@ -537,9 +556,28 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/device-registry-config/" title="Device Registry Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/device-registry-config/">
-        Device Registry Configuration
+      <li data-nav-id="/hono/docs/admin-guide/mongodb-device-registry-config/" title="MongoDB Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mongodb-device-registry-config/">
+        MongoDB Based Device Registry Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
+      <li data-nav-id="/hono/docs/admin-guide/file-based-device-registry-config/" title="File Based Device Registry Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/file-based-device-registry-config/">
+        File Based Device Registry Configuration
         
         </a>
     </li>
@@ -594,6 +632,25 @@
  
   
     
+      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
+        MQTT Adapter Configuration
+        
+        </a>
+    </li>
+     
+  
+ 
+
+            
+          
+            
+            
+
+
+ 
+  
+    
       <li data-nav-id="/hono/docs/admin-guide/amqp-adapter-config/" title="AMQP Adapter Configuration" class="dd-item ">
         <a href="/hono/docs/admin-guide/amqp-adapter-config/">
         AMQP Adapter Configuration
@@ -613,9 +670,9 @@
  
   
     
-      <li data-nav-id="/hono/docs/admin-guide/mqtt-adapter-config/" title="MQTT Adapter Configuration" class="dd-item ">
-        <a href="/hono/docs/admin-guide/mqtt-adapter-config/">
-        MQTT Adapter Configuration
+      <li data-nav-id="/hono/docs/admin-guide/coap-adapter-config/" title="CoAP Adapter Configuration" class="dd-item ">
+        <a href="/hono/docs/admin-guide/coap-adapter-config/">
+        CoAP Adapter Configuration
         
         </a>
     </li>
@@ -1277,7 +1334,27 @@
                   
                     
                     
-                      <option id="stable" value="/hono/docs/user-guide/sigfox-adapter/" selected>stable (1.2)</option>
+                      <option id="stable" value="/hono/docs/user-guide/sigfox-adapter/" selected>stable (1.3)</option>
+                    
+                  
+              
+                  
+              
+                  
+              
+                  
+              
+                  
+              
+          
+              
+              
+                  
+              
+                  
+                    
+                    
+                      <option id="1.2" value="/hono/docs/1.2/user-guide/sigfox-adapter/">1.2</option>
                     
                   
               
@@ -1293,6 +1370,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="1.1" value="/hono/docs/1.1/user-guide/sigfox-adapter/">1.1</option>
@@ -1311,6 +1390,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="1.0" value="/hono/docs/1.0/user-guide/sigfox-adapter/">1.0</option>
@@ -1329,6 +1410,8 @@
                   
               
                   
+              
+                  
                     
                     
                       <option id="dev" value="/hono/docs/dev/user-guide/sigfox-adapter/">dev</option>
@@ -1913,6 +1996,22 @@
             
                 
                     
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
                     
                 
                 
@@ -2152,6 +2251,38 @@
             
         
                     
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
+                        
+            
+            
+                
+                    
+                
+                
+
+                    
+                    
+                    
+
+                    
+            
+        
+                    
             
         
                     
@@ -2554,20 +2685,20 @@
     <div style="left: -1000px; overflow: scroll; position: absolute; top: -1000px; border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;">
       <div style="border: none; box-sizing: content-box; height: 200px; margin: 0px; padding: 0px; width: 200px;"></div>
     </div>
-    <script src="/hono/docs/js/clipboard.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595208214"></script>
-    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595208214"></script>
-    <script src="/hono/docs/js/jquery.sticky.js?1595208214"></script>
-    <script src="/hono/docs/js/featherlight.min.js?1595208214"></script>
-    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595208214"></script>
-    <script src="/hono/docs/js/highlight.pack.js?1595208214"></script>
+    <script src="/hono/docs/js/clipboard.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.min.js?1595294628"></script>
+    <script src="/hono/docs/js/perfect-scrollbar.jquery.min.js?1595294628"></script>
+    <script src="/hono/docs/js/jquery.sticky.js?1595294628"></script>
+    <script src="/hono/docs/js/featherlight.min.js?1595294628"></script>
+    <script src="/hono/docs/js/html5shiv-printshiv.min.js?1595294628"></script>
+    <script src="/hono/docs/js/highlight.pack.js?1595294628"></script>
     <script>hljs.initHighlightingOnLoad();</script>
-    <script src="/hono/docs/js/modernizr.custom.71422.js?1595208214"></script>
-    <script src="/hono/docs/js/learn.js?1595208214"></script>
-    <script src="/hono/docs/js/hugo-learn.js?1595208214"></script>
+    <script src="/hono/docs/js/modernizr.custom.71422.js?1595294628"></script>
+    <script src="/hono/docs/js/learn.js?1595294628"></script>
+    <script src="/hono/docs/js/hugo-learn.js?1595294628"></script>
 
-    <link href="/hono/docs/mermaid/mermaid.css?1595208214" type="text/css" rel="stylesheet" />
-    <script src="/hono/docs/mermaid/mermaid.js?1595208214"></script>
+    <link href="/hono/docs/mermaid/mermaid.css?1595294628" type="text/css" rel="stylesheet" />
+    <script src="/hono/docs/mermaid/mermaid.js?1595294628"></script>
     <script>
         mermaid.initialize({ startOnLoad: true });
     </script>
