diff --git a/apis/ddi_api/index.html b/apis/ddi_api/index.html
index 7243fd4..62c4216 100644
--- a/apis/ddi_api/index.html
+++ b/apis/ddi_api/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Direct Device Integration API - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -448,6 +448,18 @@
 </tr>
 
 <tr>
+<td>DOWNLOAD</td>
+<td>This can be used by the target to inform that it is downloading artifacts of the action.</td>
+<td>DOWNLOAD</td>
+</tr>
+
+<tr>
+<td>DOWNLOADED</td>
+<td>This can be used by the target to inform that it has downloaded artifacts of the action.</td>
+<td>DOWNLOADED</td>
+</tr>
+
+<tr>
 <td>PROCEEDING</td>
 <td>This can be used by the target to inform that it is working on the action.</td>
 <td>RUNNING</td>
@@ -477,7 +489,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/apis/dmf_api/index.html b/apis/dmf_api/index.html
index 1748532..c44ece6 100644
--- a/apis/dmf_api/index.html
+++ b/apis/dmf_api/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Device Management Federation API - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.73.0" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -1662,7 +1662,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/apis/index.html b/apis/index.html
index 989286c..8555d65 100644
--- a/apis/index.html
+++ b/apis/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Apis - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -439,6 +439,15 @@
 
 			<hr>
 			
+			<a href="https://www.eclipse.org/hawkbit/apis/mgmt/" title="">
+				<h2></h2>
+			</a>
+
+			<br>
+			 <br><a href="https://www.eclipse.org/hawkbit/apis/mgmt/">[...]</a>
+
+			<hr>
+			
 
 			<aside class="copyright" role="note">
   <div class="logo">
@@ -448,7 +457,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/apis/index.xml b/apis/index.xml
index b3815d4..da27368 100644
--- a/apis/index.xml
+++ b/apis/index.xml
@@ -1,15 +1,11 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
   <channel>
     <title>Apis on Eclipse hawkBit</title>
     <link>https://www.eclipse.org/hawkbit/apis/</link>
     <description>Recent content in Apis on Eclipse hawkBit</description>
     <generator>Hugo -- gohugo.io</generator>
-    <language>en-us</language>
-    
-	<atom:link href="https://www.eclipse.org/hawkbit/apis/index.xml" rel="self" type="application/rss+xml" />
-    
-    
+    <language>en-us</language><atom:link href="https://www.eclipse.org/hawkbit/apis/index.xml" rel="self" type="application/rss+xml" />
     <item>
       <title>Management API</title>
       <link>https://www.eclipse.org/hawkbit/apis/management_api/</link>
@@ -40,4 +36,4 @@
     </item>
     
   </channel>
-</rss>
\ No newline at end of file
+</rss>
diff --git a/apis/management_api/index.html b/apis/management_api/index.html
index c2eecf1..e1e0a2e 100644
--- a/apis/management_api/index.html
+++ b/apis/management_api/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Management API - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -488,7 +488,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/apis/mgmt/distributionsets/index.html b/apis/mgmt/distributionsets/index.html
index c4d6442..28a63d7 100644
--- a/apis/mgmt/distributionsets/index.html
+++ b/apis/mgmt/distributionsets/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Distribution Sets API - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -414,7 +414,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/apis/mgmt/distributionsettag/index.html b/apis/mgmt/distributionsettag/index.html
index 9b56d8d..1733274 100644
--- a/apis/mgmt/distributionsettag/index.html
+++ b/apis/mgmt/distributionsettag/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Distribution Set Tag API - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -414,7 +414,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/apis/mgmt/distributionsettypes/index.html b/apis/mgmt/distributionsettypes/index.html
index 686bfda..6d083bb 100644
--- a/apis/mgmt/distributionsettypes/index.html
+++ b/apis/mgmt/distributionsettypes/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Distribution Set Types API - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -414,7 +414,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/apis/mgmt/index.html b/apis/mgmt/index.html
index 62ea2d9..7e92b7c 100644
--- a/apis/mgmt/index.html
+++ b/apis/mgmt/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title> - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -506,7 +506,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/apis/mgmt/index.xml b/apis/mgmt/index.xml
index 4e55699..b93f2ce 100644
--- a/apis/mgmt/index.xml
+++ b/apis/mgmt/index.xml
@@ -1,15 +1,11 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
   <channel>
     <title>Eclipse hawkBit</title>
     <link>https://www.eclipse.org/hawkbit/apis/mgmt/</link>
     <description>Recent content on Eclipse hawkBit</description>
     <generator>Hugo -- gohugo.io</generator>
-    <language>en-us</language>
-    
-	<atom:link href="https://www.eclipse.org/hawkbit/apis/mgmt/index.xml" rel="self" type="application/rss+xml" />
-    
-    
+    <language>en-us</language><atom:link href="https://www.eclipse.org/hawkbit/apis/mgmt/index.xml" rel="self" type="application/rss+xml" />
     <item>
       <title>System Configuration API</title>
       <link>https://www.eclipse.org/hawkbit/apis/mgmt/tenant/</link>
@@ -101,4 +97,4 @@
     </item>
     
   </channel>
-</rss>
\ No newline at end of file
+</rss>
diff --git a/apis/mgmt/rollouts/index.html b/apis/mgmt/rollouts/index.html
index 0cf7f6d..4b763c0 100644
--- a/apis/mgmt/rollouts/index.html
+++ b/apis/mgmt/rollouts/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Rollouts API - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -414,7 +414,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/apis/mgmt/softwaremodules/index.html b/apis/mgmt/softwaremodules/index.html
index 8957780..f384544 100644
--- a/apis/mgmt/softwaremodules/index.html
+++ b/apis/mgmt/softwaremodules/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Software Modules API - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -414,7 +414,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/apis/mgmt/softwaremoduletypes/index.html b/apis/mgmt/softwaremoduletypes/index.html
index 1a1a70e..28df61f 100644
--- a/apis/mgmt/softwaremoduletypes/index.html
+++ b/apis/mgmt/softwaremoduletypes/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Software Module Types API - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -414,7 +414,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/apis/mgmt/targetfilters/index.html b/apis/mgmt/targetfilters/index.html
index d799ae9..f5f4154 100644
--- a/apis/mgmt/targetfilters/index.html
+++ b/apis/mgmt/targetfilters/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Target Filters API - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -414,7 +414,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/apis/mgmt/targets/index.html b/apis/mgmt/targets/index.html
index 3cb8c85..f7da5fe 100644
--- a/apis/mgmt/targets/index.html
+++ b/apis/mgmt/targets/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Targets API - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -414,7 +414,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/apis/mgmt/targettag/index.html b/apis/mgmt/targettag/index.html
index 0f5c024..9f5120b 100644
--- a/apis/mgmt/targettag/index.html
+++ b/apis/mgmt/targettag/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Target Tag API - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -414,7 +414,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/apis/mgmt/tenant/index.html b/apis/mgmt/tenant/index.html
index 72e2389..465131a 100644
--- a/apis/mgmt/tenant/index.html
+++ b/apis/mgmt/tenant/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>System Configuration API - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -414,7 +414,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/architecture/index.html b/architecture/index.html
index 6352313..141a870 100644
--- a/architecture/index.html
+++ b/architecture/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Architecture - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -418,7 +418,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/categories/index.html b/categories/index.html
index 72f0641..7e42108 100644
--- a/categories/index.html
+++ b/categories/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Categories - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -416,7 +416,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/categories/index.xml b/categories/index.xml
index 4998e71..845832d 100644
--- a/categories/index.xml
+++ b/categories/index.xml
@@ -1,14 +1,10 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
   <channel>
     <title>Categories on Eclipse hawkBit</title>
     <link>https://www.eclipse.org/hawkbit/categories/</link>
     <description>Recent content in Categories on Eclipse hawkBit</description>
     <generator>Hugo -- gohugo.io</generator>
-    <language>en-us</language>
-    
-	<atom:link href="https://www.eclipse.org/hawkbit/categories/index.xml" rel="self" type="application/rss+xml" />
-    
-    
+    <language>en-us</language><atom:link href="https://www.eclipse.org/hawkbit/categories/index.xml" rel="self" type="application/rss+xml" />
   </channel>
-</rss>
\ No newline at end of file
+</rss>
diff --git a/community/index.html b/community/index.html
index 37f6f7f..22eb9fc 100644
--- a/community/index.html
+++ b/community/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Community - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -422,6 +422,7 @@
 <li>01/10/2018 - Eclipse Virtual IoT Meetup - <a href="https://www.youtube.com/watch?v=8vcLXs9lc-4">video</a> - <a href="https://docs.bosch-iot-rollouts.com/slides/hawkBitIntroduction.html">slides</a></li>
 <li>10/22/2018 - Community Day EclipseCon Europe 2018 - <a href="https://www.eclipse.org/hawkbit/slides/community-day-2018.html">slides</a></li>
 <li>10/21/2019 - Community Day EclipseCon Europe 2019 - <a href="https://www.eclipse.org/hawkbit/slides/community-day-2019.html">slides</a></li>
+<li>10/19/2020 - Community Day EclipseCon Europe 2020 - <a href="https://www.eclipse.org/hawkbit/slides/community-day-2020.html">slides</a></li>
 </ul>
 
 <h2 id="articles">Articles</h2>
@@ -461,7 +462,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/concepts/authentication/index.html b/concepts/authentication/index.html
index 8f0343e..2d34238 100644
--- a/concepts/authentication/index.html
+++ b/concepts/authentication/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Authentication - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -487,7 +487,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/concepts/authorization/index.html b/concepts/authorization/index.html
index 4aa2c43..d4883ac 100644
--- a/concepts/authorization/index.html
+++ b/concepts/authorization/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Authorization - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -411,10 +411,13 @@
 
 <h2 id="ddi-api">DDI API</h2>
 
-<p>An authenticated target is permitted to:
-- retrieve commands from the server
-- provide feedback to the the server
-- download artifacts that are assigned to it</p>
+<p>An authenticated target is permitted to:</p>
+
+<ul>
+<li>retrieve commands from the server</li>
+<li>provide feedback to the the server</li>
+<li>download artifacts that are assigned to it</li>
+</ul>
 
 <p>A target might be permitted to download artifacts without authentication (if enabled, see above). Only the download can be permitted to disable the authentication. This can be used in scenarios where the artifacts itself are e.g. signed and secured.</p>
 
@@ -497,10 +500,10 @@
 <li>Permission to administrate the tenant settings.</li>
 </ul></li>
 
-<li><p>ROLLOUT_MANAGEMENT</p>
+<li><p>READ<em>/UPDATE</em>/CREATE<em>/DELETE</em>/HANDLE_/APPROVE_ROLLOUT for:</p>
 
 <ul>
-<li>Permission to provision targets through rollouts.</li>
+<li>Managing rollouts and provision targets through a rollout.</li>
 </ul></li>
 </ul>
 
@@ -517,7 +520,7 @@
 <tbody>
 <tr>
 <td>Search <em>targets</em> by installed or assigned <em>distribution set</em></td>
-<td>READ_TARGET, READ_REPOSITORY</td>
+<td>READ_REPOSITORY, READ_TARGET</td>
 </tr>
 
 <tr>
@@ -527,17 +530,17 @@
 
 <tr>
 <td>Assign DS to target through a <em>Rollout</em>, i.e. <em>Rollout</em> creation and start</td>
-<td>READ_REPOSITORY, UPDATE_TARGET, ROLLOUT_MANAGEMENT</td>
+<td>READ_REPOSITORY, READ_TARGET, READ_ROLLOUT, CREATE_ROLLOUT, HANDLE_ROLLOUT</td>
 </tr>
 
 <tr>
 <td>Read <em>Rollout</em> status including its <em>deployment groups</em></td>
-<td>ROLLOUT_MANAGEMENT</td>
+<td>READ_REPOSITORY, READ_ROLLOUT</td>
 </tr>
 
 <tr>
 <td>Checks <em>targets</em> inside <em>Rollout deployment group</em></td>
-<td>READ_TARGET, ROLLOUT_MANAGEMENT</td>
+<td>READ_REPOSITORY, READ_TARGET, READ_ROLLOUT</td>
 </tr>
 </tbody>
 </table>
@@ -554,7 +557,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/concepts/datamodel/index.html b/concepts/datamodel/index.html
index ad39abd..396ab18 100644
--- a/concepts/datamodel/index.html
+++ b/concepts/datamodel/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Data Model - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -454,7 +454,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/concepts/index.html b/concepts/index.html
index b5530da..4f24b5d 100644
--- a/concepts/index.html
+++ b/concepts/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Concepts - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -415,14 +415,15 @@
 			</a>
 
 			<br>
-			A hawkBit update server can be accessed in four different ways:</p>
+			<p>A hawkBit update server can be accessed in four different ways:</p>
 
 <ul>
 <li><em>Direct Device Integration (DDI) API</em> by <strong>targets</strong>.</li>
 <li><em>Management API</em> by 3rd party <strong>applications</strong>.</li>
 <li><em>Device Management Federation (DMF) API</em> by 3rd party <strong>applications</strong> through AMQP.</li>
 <li><em>Management UI</em> by <strong>users</strong>.</li>
-</ul> <br><a href="https://www.eclipse.org/hawkbit/concepts/authentication/">[...]</a>
+</ul>
+ <br><a href="https://www.eclipse.org/hawkbit/concepts/authentication/">[...]</a>
 
 			<hr>
 			
@@ -471,7 +472,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/concepts/index.xml b/concepts/index.xml
index ee704ad..5985ba5 100644
--- a/concepts/index.xml
+++ b/concepts/index.xml
@@ -1,15 +1,11 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
   <channel>
     <title>Concepts on Eclipse hawkBit</title>
     <link>https://www.eclipse.org/hawkbit/concepts/</link>
     <description>Recent content in Concepts on Eclipse hawkBit</description>
     <generator>Hugo -- gohugo.io</generator>
-    <language>en-us</language>
-    
-	<atom:link href="https://www.eclipse.org/hawkbit/concepts/index.xml" rel="self" type="application/rss+xml" />
-    
-    
+    <language>en-us</language><atom:link href="https://www.eclipse.org/hawkbit/concepts/index.xml" rel="self" type="application/rss+xml" />
     <item>
       <title>Authentication</title>
       <link>https://www.eclipse.org/hawkbit/concepts/authentication/</link>
@@ -63,4 +59,4 @@
     </item>
     
   </channel>
-</rss>
\ No newline at end of file
+</rss>
diff --git a/concepts/rollout-management/index.html b/concepts/rollout-management/index.html
index ddd4b32..70d6ce3 100644
--- a/concepts/rollout-management/index.html
+++ b/concepts/rollout-management/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Rollout Management - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -493,7 +493,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/concepts/targetstate/index.html b/concepts/targetstate/index.html
index 9372a36..da50a87 100644
--- a/concepts/targetstate/index.html
+++ b/concepts/targetstate/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Target State Machine - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -455,7 +455,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/features/index.html b/features/index.html
index 55bbe5f..ba158af 100644
--- a/features/index.html
+++ b/features/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Features - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -501,7 +501,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/gettingstarted/index.html b/gettingstarted/index.html
index 060fd61..183734c 100644
--- a/gettingstarted/index.html
+++ b/gettingstarted/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Getting Started - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -423,7 +423,8 @@
 <p>In addition, the following vendors offer free trial accounts for their Eclipse hawkBit compatible products:</p>
 
 <ul>
-<li><a href="https://www.bosch-iot-suite.com/rollouts/#plans">Bosch IoT Rollouts</a> (by <a href="https://www.bosch-si.com/corporate/home/homepage.html">Bosch Software Innovations GmbH</a>)</li>
+<li><a href="https://www.bosch-iot-suite.com/rollouts/#plans">Bosch IoT Rollouts</a> (by <a href="https://bosch.io/">Bosch.IO GmbH</a>)</li>
+<li><a href="https://www.kynetics.com/update-factory">Kynetics Update Factory</a> (by <a href="https://www.kynetics.com/">Kynetics LLC</a>)</li>
 </ul>
 
 <h2 id="from-docker-image">From Docker Image</h2>
@@ -537,7 +538,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/guides/clustering/index.html b/guides/clustering/index.html
index 05c9689..2d90a38 100644
--- a/guides/clustering/index.html
+++ b/guides/clustering/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Clustering - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -456,7 +456,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/guides/customtheme/index.html b/guides/customtheme/index.html
index eab0da7..451b8c8 100644
--- a/guides/customtheme/index.html
+++ b/guides/customtheme/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Custom Theme - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -462,7 +462,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/guides/feignclient/index.html b/guides/feignclient/index.html
index 306bf92..33cdd5f 100644
--- a/guides/feignclient/index.html
+++ b/guides/feignclient/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Feign Client - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -465,7 +465,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/guides/index.html b/guides/index.html
index b032e76..9d00c84 100644
--- a/guides/index.html
+++ b/guides/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Guides - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -455,7 +455,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/guides/index.xml b/guides/index.xml
index b44811f..2334596 100644
--- a/guides/index.xml
+++ b/guides/index.xml
@@ -1,15 +1,11 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
   <channel>
     <title>Guides on Eclipse hawkBit</title>
     <link>https://www.eclipse.org/hawkbit/guides/</link>
     <description>Recent content in Guides on Eclipse hawkBit</description>
     <generator>Hugo -- gohugo.io</generator>
-    <language>en-us</language>
-    
-	<atom:link href="https://www.eclipse.org/hawkbit/guides/index.xml" rel="self" type="application/rss+xml" />
-    
-    
+    <language>en-us</language><atom:link href="https://www.eclipse.org/hawkbit/guides/index.xml" rel="self" type="application/rss+xml" />
     <item>
       <title>Run hawkBit</title>
       <link>https://www.eclipse.org/hawkbit/guides/runhawkbit/</link>
@@ -47,4 +43,4 @@
     </item>
     
   </channel>
-</rss>
\ No newline at end of file
+</rss>
diff --git a/guides/runhawkbit/index.html b/guides/runhawkbit/index.html
index 423c921..78e568e 100644
--- a/guides/runhawkbit/index.html
+++ b/guides/runhawkbit/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Run hawkBit - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -420,7 +420,7 @@
 <li><a href="https://www.rabbitmq.com">RabbitMQ</a> for DMF communication.</li>
 <li>For testing and demonstration purposes we will also use:</li>
 <li><a href="https://github.com/eclipse/hawkbit-examples/tree/master/hawkbit-device-simulator">hawkBit Device Simulator</a>.</li>
-<li><a href="https://github.com/eclipse/hawkbit-examples/tree/master/hawkbit-mgmt-api-client">hawkBit Management API example client</a>.</li>
+<li><a href="https://github.com/eclipse/hawkbit-examples/tree/master/hawkbit-example-mgmt-feign-client">hawkBit Management API example client</a>.</li>
 </ul>
 
 <h2 id="prerequisites">Prerequisites</h2>
@@ -454,6 +454,9 @@
 spring.datasource.driverClassName=org.mariadb.jdbc.Driver
 </code></pre>
 
+<p>Note: On Ubuntu 18.04 with MariaDB 10.1 installed from the default repository via apt install <em>COLLATE option</em> of database have to be changed manually to &ldquo;latin1&rdquo;.
+For recent versions of MariaDB running on Ubuntu this is not required (cf. <a href="https://mariadb.com/kb/en/differences-in-mariadb-in-debian-and-ubuntu">system variables</a>, <a href="https://github.com/eclipse/hawkbit/issues/963">issue</a>)</p>
+
 <h3 id="configure-rabbitmq-connection-settings-for-update-server-and-device-simulator-optional">Configure RabbitMQ connection settings for update server and device simulator (optional).</h3>
 
 <p>We provide already defaults that should work with a standard Rabbit installation. Otherwise configure the following in the <code>application.properties</code> of the two services:</p>
@@ -507,7 +510,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/index.html b/index.html
index 996568d..15571e9 100644
--- a/index.html
+++ b/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -471,7 +471,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/index.xml b/index.xml
index 88a0f9f..9c13ebc 100644
--- a/index.xml
+++ b/index.xml
@@ -1,15 +1,11 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
   <channel>
     <title>Eclipse hawkBit</title>
     <link>https://www.eclipse.org/hawkbit/</link>
     <description>Recent content on Eclipse hawkBit</description>
     <generator>Hugo -- gohugo.io</generator>
-    <language>en-us</language>
-    
-	<atom:link href="https://www.eclipse.org/hawkbit/index.xml" rel="self" type="application/rss+xml" />
-    
-    
+    <language>en-us</language><atom:link href="https://www.eclipse.org/hawkbit/index.xml" rel="self" type="application/rss+xml" />
     <item>
       <title>Eclipse hawkBit 0.2.0 - First Release</title>
       <link>https://www.eclipse.org/hawkbit/news/2018-07-26-first-release/</link>
@@ -129,7 +125,7 @@
       <description>On Sandbox We offer a sandbox installation that is free for everyone to try out hawkBit&amp;rsquo;s Management UI, Management API, and Direct Device Integration API: &amp;nbsp; &amp;nbsp; https://hawkbit.eclipse.org
 The sandbox is a shared installation that will be reset from time to time. Therefore, it is not allowed to upload any personal data.
  In addition, the following vendors offer free trial accounts for their Eclipse hawkBit compatible products:
- Bosch IoT Rollouts (by Bosch Software Innovations GmbH)  From Docker Image Overview    Service / Container A B C     hawkBit Update Server &amp;#10003; &amp;#10003; &amp;#10003;   hawkBit Device Simulator   &amp;#10003;   MySQL  &amp;#10003; &amp;#10003;   RabbitMQ  &amp;#10003; &amp;#10003;    A: Run hawkBit Update Server as Docker Container Start the hawkBit Update Server as a single container</description>
+ Bosch IoT Rollouts (by Bosch.</description>
     </item>
     
     <item>
@@ -284,7 +280,7 @@
       
       <guid>https://www.eclipse.org/hawkbit/community/</guid>
       <description>Presentations Here you can find links to arbitrary material covering Eclipse hawkBit which has been presented at events, conferences and meet-ups.
- 09/23/2015 - Eclipse IoT Working Group meeting - slides 04/11/2015 - EclipseCon Europe 2015 - slides 03/09/2016 - EclipseCon North America 2016 - slides 05/16/2016 - Eclipse Virtual IoT Meetup - video - slides 03/20/2017 - Eclipse IoT Day SanJose, CA - video - slides 09/12/2017 - Eclipse IoT Day ThingMonk 2017 - video 01/10/2018 - Eclipse Virtual IoT Meetup - video - slides 10/22/2018 - Community Day EclipseCon Europe 2018 - slides 10/21/2019 - Community Day EclipseCon Europe 2019 - slides  Articles  10/27/2015 - Why software provisioning goes open source - article 05/25/2016 - jaxenter: Eclipse hawkBit - english - german 09/27/2016 - Eclipse Newsletter - &amp;lsquo;IoT is the new black&amp;rsquo; - article  Ask a question Visit stackoverflow.</description>
+ 09/23/2015 - Eclipse IoT Working Group meeting - slides 04/11/2015 - EclipseCon Europe 2015 - slides 03/09/2016 - EclipseCon North America 2016 - slides 05/16/2016 - Eclipse Virtual IoT Meetup - video - slides 03/20/2017 - Eclipse IoT Day SanJose, CA - video - slides 09/12/2017 - Eclipse IoT Day ThingMonk 2017 - video 01/10/2018 - Eclipse Virtual IoT Meetup - video - slides 10/22/2018 - Community Day EclipseCon Europe 2018 - slides 10/21/2019 - Community Day EclipseCon Europe 2019 - slides 10/19/2020 - Community Day EclipseCon Europe 2020 - slides  Articles  10/27/2015 - Why software provisioning goes open source - article 05/25/2016 - jaxenter: Eclipse hawkBit - english - german 09/27/2016 - Eclipse Newsletter - &amp;lsquo;IoT is the new black&amp;rsquo; - article  Ask a question Visit stackoverflow.</description>
     </item>
     
     <item>
@@ -293,112 +289,13 @@
       <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
       
       <guid>https://www.eclipse.org/hawkbit/release-notes/</guid>
-      <description>0.3.0M6 Release Date: Friday, January 17, 2020 Tag / Release
+      <description>0.3.0M7 Release Date: Monday, February 15, 2021 Hawkbit: Tag / Release Extensions: Tag / Release
+0.3.0M6 Release Date: Friday, January 17, 2020 Tag / Release
 0.3.0M5 Release Date: Tuesday, July 29, 2019 Tag / Release
 0.3.0M4 Release Date: Thursday, June 6, 2019 Tag / Release
 0.3.0M3 Release Date: Tuesday, May 21, 2019 Tag / Release
 0.3.0M2 Release Date: Tuesday, April 2, 2019 Tag / Release
-0.3.0M1 Release Date: Saturday, February 2, 2019 Tag / Release
-0.2.5 Release Date: Friday, November 30, 2018 Tag / Release</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/distributionsets-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/distributionsets-api-guide/</guid>
-      <description>Distributionsets  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em .</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/distributionsettag-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/distributionsettag-api-guide/</guid>
-      <description>Distribution set Tag  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/distributionsettypes-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/distributionsettypes-api-guide/</guid>
-      <description>Distribution Set Types  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/rollout-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/rollout-api-guide/</guid>
-      <description>Rollouts  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em .</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/rootcontroller-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/rootcontroller-api-guide/</guid>
-      <description>Root Controller  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/softwaremodules-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/softwaremodules-api-guide/</guid>
-      <description>Software Modules  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/softwaremoduletypes-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/softwaremoduletypes-api-guide/</guid>
-      <description>Software Module Types  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/targetfilters-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/targetfilters-api-guide/</guid>
-      <description>Target filter queries  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/targets-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/targets-api-guide/</guid>
-      <description>Targets  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em .</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/targettag-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/targettag-api-guide/</guid>
-      <description>Target Tag  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/tenant-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/tenant-api-guide/</guid>
-      <description>System Configuration  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .</description>
+0.3.0M1 Release Date: Saturday, February 2, 2019 Tag / Release</description>
     </item>
     
     <item>
@@ -411,4 +308,4 @@
     </item>
     
   </channel>
-</rss>
\ No newline at end of file
+</rss>
diff --git a/news/2018-07-26-first-release/index.html b/news/2018-07-26-first-release/index.html
index bfa3cf3..65be66f 100644
--- a/news/2018-07-26-first-release/index.html
+++ b/news/2018-07-26-first-release/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Eclipse hawkBit 0.2.0 - First Release - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -526,7 +526,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/news/index.html b/news/index.html
index 2c3704d..ed9f0fa 100644
--- a/news/index.html
+++ b/news/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title> - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -426,7 +426,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/news/index.xml b/news/index.xml
index 8e58362..28c69bd 100644
--- a/news/index.xml
+++ b/news/index.xml
@@ -1,15 +1,11 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
   <channel>
     <title>Eclipse hawkBit</title>
     <link>https://www.eclipse.org/hawkbit/news/</link>
     <description>Recent content on Eclipse hawkBit</description>
     <generator>Hugo -- gohugo.io</generator>
-    <language>en-us</language>
-    
-	<atom:link href="https://www.eclipse.org/hawkbit/news/index.xml" rel="self" type="application/rss+xml" />
-    
-    
+    <language>en-us</language><atom:link href="https://www.eclipse.org/hawkbit/news/index.xml" rel="self" type="application/rss+xml" />
     <item>
       <title>Eclipse hawkBit 0.2.0 - First Release</title>
       <link>https://www.eclipse.org/hawkbit/news/2018-07-26-first-release/</link>
@@ -21,4 +17,4 @@
     </item>
     
   </channel>
-</rss>
\ No newline at end of file
+</rss>
diff --git a/release-notes/index.html b/release-notes/index.html
index ac5ed55..a54f1c3 100644
--- a/release-notes/index.html
+++ b/release-notes/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Release notes - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -408,6 +408,14 @@
 
 			
 
+<h2 id="0-3-0m7">0.3.0M7</h2>
+
+<p><strong>Release Date:</strong> Monday, February 15, 2021 <br />
+Hawkbit: <a href="https://github.com/eclipse/hawkbit/releases/tag/0.3.0M7">Tag</a> /
+         <a href="https://github.com/eclipse/hawkbit/milestone/22?closed=1">Release</a> <br />
+Extensions: <a href="https://github.com/eclipse/hawkbit-extensions/releases/tag/0.3.0M7">Tag</a> /
+            <a href="https://github.com/eclipse/hawkbit-extensions/milestone/1?closed=1">Release</a></p>
+
 <h2 id="0-3-0m6">0.3.0M6</h2>
 
 <p><strong>Release Date:</strong> Friday, January 17, 2020 <br />
@@ -511,7 +519,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
@@ -544,7 +552,7 @@
 <nav class="pagination" aria-label="Footer">
   <div class="previous">
   
-      <a href="https://www.eclipse.org/hawkbit/rest-api/distributionsets-api-guide/" title="">
+      <a href="https://www.eclipse.org/hawkbit/sandbox/" title="Sandbox">
         <span class="direction">
           Previous
         </span>
@@ -554,7 +562,7 @@
           </div>
           <div class="stretch">
             <div class="title">
-              
+              Sandbox
             </div>
           </div>
         </div>
diff --git a/rest-api/index.html b/rest-api/index.html
index 830368c..ce48c06 100644
--- a/rest-api/index.html
+++ b/rest-api/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title> - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -407,105 +407,6 @@
 			<h1>Pages in </h1>
 
 			
-			<a href="https://www.eclipse.org/hawkbit/rest-api/distributionsets-api-guide/" title="">
-				<h2></h2>
-			</a>
-
-			<br>
-			Distributionsets  /* Asciidoctor default stylesheet | MIT License | <a href="http://asciidoctor.org">http://asciidoctor.org</a> <em>/ /</em> Remove the comments around the @import statement below when using this as a custom stylesheet <em>/ /</em>@import &ldquo;<a href="https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/">https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/</a> article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&rdquo;\201C&rdquo; &ldquo;\201D&rdquo; &ldquo;\2018&rdquo; &ldquo;\2019&rdquo;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em . <br><a href="https://www.eclipse.org/hawkbit/rest-api/distributionsets-api-guide/">[...]</a>
-
-			<hr>
-			
-			<a href="https://www.eclipse.org/hawkbit/rest-api/distributionsettag-api-guide/" title="">
-				<h2></h2>
-			</a>
-
-			<br>
-			Distribution set Tag  /* Asciidoctor default stylesheet | MIT License | <a href="http://asciidoctor.org">http://asciidoctor.org</a> <em>/ /</em> Remove the comments around the @import statement below when using this as a custom stylesheet <em>/ /</em>@import &ldquo;<a href="https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/">https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/</a> article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&rdquo;\201C&rdquo; &ldquo;\201D&rdquo; &ldquo;\2018&rdquo; &ldquo;\2019&rdquo;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:. <br><a href="https://www.eclipse.org/hawkbit/rest-api/distributionsettag-api-guide/">[...]</a>
-
-			<hr>
-			
-			<a href="https://www.eclipse.org/hawkbit/rest-api/distributionsettypes-api-guide/" title="">
-				<h2></h2>
-			</a>
-
-			<br>
-			Distribution Set Types  /* Asciidoctor default stylesheet | MIT License | <a href="http://asciidoctor.org">http://asciidoctor.org</a> <em>/ /</em> Remove the comments around the @import statement below when using this as a custom stylesheet <em>/ /</em>@import &ldquo;<a href="https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/">https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/</a> article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&rdquo;\201C&rdquo; &ldquo;\201D&rdquo; &ldquo;\2018&rdquo; &ldquo;\2019&rdquo;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:. <br><a href="https://www.eclipse.org/hawkbit/rest-api/distributionsettypes-api-guide/">[...]</a>
-
-			<hr>
-			
-			<a href="https://www.eclipse.org/hawkbit/rest-api/rollout-api-guide/" title="">
-				<h2></h2>
-			</a>
-
-			<br>
-			Rollouts  /* Asciidoctor default stylesheet | MIT License | <a href="http://asciidoctor.org">http://asciidoctor.org</a> <em>/ /</em> Remove the comments around the @import statement below when using this as a custom stylesheet <em>/ /</em>@import &ldquo;<a href="https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/">https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/</a> article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&rdquo;\201C&rdquo; &ldquo;\201D&rdquo; &ldquo;\2018&rdquo; &ldquo;\2019&rdquo;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em . <br><a href="https://www.eclipse.org/hawkbit/rest-api/rollout-api-guide/">[...]</a>
-
-			<hr>
-			
-			<a href="https://www.eclipse.org/hawkbit/rest-api/rootcontroller-api-guide/" title="">
-				<h2></h2>
-			</a>
-
-			<br>
-			Root Controller  /* Asciidoctor default stylesheet | MIT License | <a href="http://asciidoctor.org">http://asciidoctor.org</a> <em>/ /</em> Remove the comments around the @import statement below when using this as a custom stylesheet <em>/ /</em>@import &ldquo;<a href="https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/">https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/</a> article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&rdquo;\201C&rdquo; &ldquo;\201D&rdquo; &ldquo;\2018&rdquo; &ldquo;\2019&rdquo;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em . <br><a href="https://www.eclipse.org/hawkbit/rest-api/rootcontroller-api-guide/">[...]</a>
-
-			<hr>
-			
-			<a href="https://www.eclipse.org/hawkbit/rest-api/softwaremodules-api-guide/" title="">
-				<h2></h2>
-			</a>
-
-			<br>
-			Software Modules  /* Asciidoctor default stylesheet | MIT License | <a href="http://asciidoctor.org">http://asciidoctor.org</a> <em>/ /</em> Remove the comments around the @import statement below when using this as a custom stylesheet <em>/ /</em>@import &ldquo;<a href="https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/">https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/</a> article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&rdquo;\201C&rdquo; &ldquo;\201D&rdquo; &ldquo;\2018&rdquo; &ldquo;\2019&rdquo;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em . <br><a href="https://www.eclipse.org/hawkbit/rest-api/softwaremodules-api-guide/">[...]</a>
-
-			<hr>
-			
-			<a href="https://www.eclipse.org/hawkbit/rest-api/softwaremoduletypes-api-guide/" title="">
-				<h2></h2>
-			</a>
-
-			<br>
-			Software Module Types  /* Asciidoctor default stylesheet | MIT License | <a href="http://asciidoctor.org">http://asciidoctor.org</a> <em>/ /</em> Remove the comments around the @import statement below when using this as a custom stylesheet <em>/ /</em>@import &ldquo;<a href="https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/">https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/</a> article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&rdquo;\201C&rdquo; &ldquo;\201D&rdquo; &ldquo;\2018&rdquo; &ldquo;\2019&rdquo;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:. <br><a href="https://www.eclipse.org/hawkbit/rest-api/softwaremoduletypes-api-guide/">[...]</a>
-
-			<hr>
-			
-			<a href="https://www.eclipse.org/hawkbit/rest-api/targetfilters-api-guide/" title="">
-				<h2></h2>
-			</a>
-
-			<br>
-			Target filter queries  /* Asciidoctor default stylesheet | MIT License | <a href="http://asciidoctor.org">http://asciidoctor.org</a> <em>/ /</em> Remove the comments around the @import statement below when using this as a custom stylesheet <em>/ /</em>@import &ldquo;<a href="https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/">https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/</a> article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&rdquo;\201C&rdquo; &ldquo;\201D&rdquo; &ldquo;\2018&rdquo; &ldquo;\2019&rdquo;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:. <br><a href="https://www.eclipse.org/hawkbit/rest-api/targetfilters-api-guide/">[...]</a>
-
-			<hr>
-			
-			<a href="https://www.eclipse.org/hawkbit/rest-api/targets-api-guide/" title="">
-				<h2></h2>
-			</a>
-
-			<br>
-			Targets  /* Asciidoctor default stylesheet | MIT License | <a href="http://asciidoctor.org">http://asciidoctor.org</a> <em>/ /</em> Remove the comments around the @import statement below when using this as a custom stylesheet <em>/ /</em>@import &ldquo;<a href="https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/">https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/</a> article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&rdquo;\201C&rdquo; &ldquo;\201D&rdquo; &ldquo;\2018&rdquo; &ldquo;\2019&rdquo;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em . <br><a href="https://www.eclipse.org/hawkbit/rest-api/targets-api-guide/">[...]</a>
-
-			<hr>
-			
-			<a href="https://www.eclipse.org/hawkbit/rest-api/targettag-api-guide/" title="">
-				<h2></h2>
-			</a>
-
-			<br>
-			Target Tag  /* Asciidoctor default stylesheet | MIT License | <a href="http://asciidoctor.org">http://asciidoctor.org</a> <em>/ /</em> Remove the comments around the @import statement below when using this as a custom stylesheet <em>/ /</em>@import &ldquo;<a href="https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/">https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/</a> article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&rdquo;\201C&rdquo; &ldquo;\201D&rdquo; &ldquo;\2018&rdquo; &ldquo;\2019&rdquo;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em . <br><a href="https://www.eclipse.org/hawkbit/rest-api/targettag-api-guide/">[...]</a>
-
-			<hr>
-			
-			<a href="https://www.eclipse.org/hawkbit/rest-api/tenant-api-guide/" title="">
-				<h2></h2>
-			</a>
-
-			<br>
-			System Configuration  /* Asciidoctor default stylesheet | MIT License | <a href="http://asciidoctor.org">http://asciidoctor.org</a> <em>/ /</em> Remove the comments around the @import statement below when using this as a custom stylesheet <em>/ /</em>@import &ldquo;<a href="https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/">https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&quot;;*/</a> article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&rdquo;\201C&rdquo; &ldquo;\201D&rdquo; &ldquo;\2018&rdquo; &ldquo;\2019&rdquo;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em . <br><a href="https://www.eclipse.org/hawkbit/rest-api/tenant-api-guide/">[...]</a>
-
-			<hr>
-			
 
 			<aside class="copyright" role="note">
   <div class="logo">
@@ -515,7 +416,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/rest-api/index.xml b/rest-api/index.xml
index f5b835a..6eca452 100644
--- a/rest-api/index.xml
+++ b/rest-api/index.xml
@@ -1,113 +1,10 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
   <channel>
     <title>Eclipse hawkBit</title>
     <link>https://www.eclipse.org/hawkbit/rest-api/</link>
     <description>Recent content on Eclipse hawkBit</description>
     <generator>Hugo -- gohugo.io</generator>
-    <language>en-us</language>
-    
-	<atom:link href="https://www.eclipse.org/hawkbit/rest-api/index.xml" rel="self" type="application/rss+xml" />
-    
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/distributionsets-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/distributionsets-api-guide/</guid>
-      <description>Distributionsets  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em .</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/distributionsettag-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/distributionsettag-api-guide/</guid>
-      <description>Distribution set Tag  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/distributionsettypes-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/distributionsettypes-api-guide/</guid>
-      <description>Distribution Set Types  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/rollout-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/rollout-api-guide/</guid>
-      <description>Rollouts  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em .</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/rootcontroller-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/rootcontroller-api-guide/</guid>
-      <description>Root Controller  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/softwaremodules-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/softwaremodules-api-guide/</guid>
-      <description>Software Modules  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/softwaremoduletypes-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/softwaremoduletypes-api-guide/</guid>
-      <description>Software Module Types  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/targetfilters-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/targetfilters-api-guide/</guid>
-      <description>Target filter queries  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/targets-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/targets-api-guide/</guid>
-      <description>Targets  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em .</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/targettag-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/targettag-api-guide/</guid>
-      <description>Target Tag  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .</description>
-    </item>
-    
-    <item>
-      <title></title>
-      <link>https://www.eclipse.org/hawkbit/rest-api/tenant-api-guide/</link>
-      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
-      
-      <guid>https://www.eclipse.org/hawkbit/rest-api/tenant-api-guide/</guid>
-      <description>System Configuration  /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */ /* Remove the comments around the @import statement below when using this as a custom stylesheet */ /*@import &#34;https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400&#34;;*/ article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block} audio,canvas,video{display:inline-block} audio:not([controls]){display:none;height:0} [hidden],template{display:none} script{display:none!important} html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%} body{margin:0} a{background:transparent} a:focus{outline:thin dotted} a:active,a:hover{outline:0} h1{font-size:2em;margin:.67em 0} abbr[title]{border-bottom:1px dotted} b,strong{font-weight:bold} dfn{font-style:italic} hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0} mark{background:#ff0;color:#000} code,kbd,pre,samp{font-family:monospace;font-size:1em} pre{white-space:pre-wrap} q{quotes:&#34;\201C&#34; &#34;\201D&#34; &#34;\2018&#34; &#34;\2019&#34;} small{font-size:80%} sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline} sup{top:-.5em} sub{bottom:-.25em} img{border:0} svg:not(:root){overflow:hidden} figure{margin:0} fieldset{border:1px solid silver;margin:0 2px;padding:.35em .</description>
-    </item>
-    
+    <language>en-us</language><atom:link href="https://www.eclipse.org/hawkbit/rest-api/index.xml" rel="self" type="application/rss+xml" />
   </channel>
-</rss>
\ No newline at end of file
+</rss>
diff --git a/sandbox/index.html b/sandbox/index.html
index f41172b..1113ca6 100644
--- a/sandbox/index.html
+++ b/sandbox/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Sandbox - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -413,7 +413,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
@@ -450,14 +450,14 @@
 
   <div class="next">
   
-      <a href="https://www.eclipse.org/hawkbit/rest-api/tenant-api-guide/" title="">
+      <a href="https://www.eclipse.org/hawkbit/release-notes/" title="Release notes">
         <span class="direction">
           Next
         </span>
         <div class="page">
           <div class="stretch">
             <div class="title">
-              
+              Release notes
             </div>
           </div>
           <div class="button button-next" role="button" aria-label="Next">
diff --git a/sitemap.xml b/sitemap.xml
index 2c2299c..ce8cae6 100644
--- a/sitemap.xml
+++ b/sitemap.xml
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
   xmlns:xhtml="http://www.w3.org/1999/xhtml">
   
@@ -124,7 +124,6 @@
   
   <url>
     <loc>https://www.eclipse.org/hawkbit/apis/mgmt/</loc>
-    <priority>0</priority>
   </url>
   
   <url>
@@ -138,83 +137,23 @@
   </url>
   
   <url>
-    <loc>https://www.eclipse.org/hawkbit/rest-api/distributionsets-api-guide/</loc>
-    <priority>0</priority>
-  </url>
-  
-  <url>
-    <loc>https://www.eclipse.org/hawkbit/rest-api/distributionsettag-api-guide/</loc>
-    <priority>0</priority>
-  </url>
-  
-  <url>
-    <loc>https://www.eclipse.org/hawkbit/rest-api/distributionsettypes-api-guide/</loc>
-    <priority>0</priority>
-  </url>
-  
-  <url>
-    <loc>https://www.eclipse.org/hawkbit/rest-api/rollout-api-guide/</loc>
-    <priority>0</priority>
-  </url>
-  
-  <url>
-    <loc>https://www.eclipse.org/hawkbit/rest-api/rootcontroller-api-guide/</loc>
-    <priority>0</priority>
-  </url>
-  
-  <url>
-    <loc>https://www.eclipse.org/hawkbit/rest-api/softwaremodules-api-guide/</loc>
-    <priority>0</priority>
-  </url>
-  
-  <url>
-    <loc>https://www.eclipse.org/hawkbit/rest-api/softwaremoduletypes-api-guide/</loc>
-    <priority>0</priority>
-  </url>
-  
-  <url>
-    <loc>https://www.eclipse.org/hawkbit/rest-api/targetfilters-api-guide/</loc>
-    <priority>0</priority>
-  </url>
-  
-  <url>
-    <loc>https://www.eclipse.org/hawkbit/rest-api/targets-api-guide/</loc>
-    <priority>0</priority>
-  </url>
-  
-  <url>
-    <loc>https://www.eclipse.org/hawkbit/rest-api/targettag-api-guide/</loc>
-    <priority>0</priority>
-  </url>
-  
-  <url>
-    <loc>https://www.eclipse.org/hawkbit/rest-api/tenant-api-guide/</loc>
-    <priority>0</priority>
-  </url>
-  
-  <url>
     <loc>https://www.eclipse.org/hawkbit/apis/</loc>
-    <priority>0</priority>
   </url>
   
   <url>
     <loc>https://www.eclipse.org/hawkbit/categories/</loc>
-    <priority>0</priority>
   </url>
   
   <url>
     <loc>https://www.eclipse.org/hawkbit/concepts/</loc>
-    <priority>0</priority>
   </url>
   
   <url>
     <loc>https://www.eclipse.org/hawkbit/</loc>
-    <priority>0</priority>
   </url>
   
   <url>
     <loc>https://www.eclipse.org/hawkbit/guides/</loc>
-    <priority>0</priority>
   </url>
   
   <url>
@@ -223,7 +162,6 @@
   
   <url>
     <loc>https://www.eclipse.org/hawkbit/tags/</loc>
-    <priority>0</priority>
   </url>
   
-</urlset>
\ No newline at end of file
+</urlset>
diff --git a/slides/community-day-2020.html b/slides/community-day-2020.html
new file mode 100644
index 0000000..408fc9d
--- /dev/null
+++ b/slides/community-day-2020.html
@@ -0,0 +1,185 @@
+<!--
+  ~ Copyright (c) 2020 Bosch.IO GmbH and others.
+  ~
+  ~ All rights reserved. This program and the accompanying materials
+  ~ are made available under the terms of the Eclipse Public License v1.0
+  ~ which accompanies this distribution, and is available at
+  ~ http://www.eclipse.org/legal/epl-v10.html
+  -->
+
+<!doctype html>
+<html lang="en">
+
+<head>
+    <meta charset="utf-8">
+
+    <title>Eclipse hawkBit</title>
+
+    <meta name="description" content="Eclipse hawkBit - Community Day 2020">
+
+    <meta name="apple-mobile-web-app-capable" content="yes" />
+    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
+    <meta name="viewport"
+        content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, minimal-ui">
+
+    <link rel="stylesheet" href="css/reveal.css">
+    <link rel="stylesheet" href="css/theme/hawkBit.css" id="theme">
+    <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.3.1/css/all.css"
+        integrity="sha384-mzrmE5qonljUremFsqc01SB46JvROS7bZs3IO2EmfFsd15uHvIt+Y8vEf7N7fWAU" crossorigin="anonymous">
+
+<body>
+    <div class="reveal">
+        <div class="header">
+            <img src="resources/images/hawkbit_logo.png" width="120px" align="right" />
+        </div>
+        <div class="slides">
+            <section>
+                <div class="intro">
+                    <h1>Community Day - Eclipse hawkBit</h1>
+                    <h6>EclipseCon Europe 2020</h6>
+                </div>
+            </section>
+            <section>
+                <h1>About</h1>
+                <p>
+                    Eclipse hawkBit aims to create a <b>domain independent</b> back end solution for rolling out
+                    <b>software
+                        updates</b>
+                    to constrained edge devices as well as more powerful controllers and gateways connected to IP based
+                    networking infrastructure
+                </p>
+            </section>
+            <section>
+                <h1>Big picture</h1>
+                <img src="resources/images/hawkBit_overview.jpg">
+            </section>
+            <section>
+                <h1>Statistics (10/2020)</h1>
+                <ul style="position:absolute; left:2em;">
+                    <li style="margin-bottom: 0.5em"><a href="https://github.com/eclipse/hawkbit">hawkbit Core</a>: 261
+                        (+54)
+                        stars, 797 (+80) PRs, 185 (+13) issues</li>
+                    <li style="margin-bottom: 0.5em"><a href="https://github.com/eclipse/hawkbit-extensions">hawkbit
+                            Extensions</a>: 46 (+5) PRs</li>
+                    <li style="margin-bottom: 0.5em"><a href="https://github.com/eclipse/hawkbit-examples">hawkbit
+                            Examples</a>: 39 (+4) PRs</li>
+                    <li style="margin-bottom: 0.5em"><a href="https://hub.docker.com/u/hawkbit/">Docker Hub</a>: 100K+
+                        (+50K)
+                        PULLS</li>
+                </ul>
+            </section>
+            <section>
+                <h1>We have been busy</h1>
+                <ul style="position:absolute; left:2em;">
+                    <li style="margin-bottom: 0.5em">Migrate hawkBit UI to VAADIN 8 (<a
+                            href="https://github.com/eclipse/hawkbit/pull/980">#980</a>)</li>
+                    <li style="margin-bottom: 0.5em">Support PostgreSQL (<a
+                            href="https://github.com/eclipse/hawkbit/pull/932">#932</a>)</li>
+                    <li style="margin-bottom: 0.5em">Allowing artifact download from within the UI (<a
+                            href="https://github.com/eclipse/hawkbit/pull/944">#944</a>)</li>
+                    <li style="margin-bottom: 0.5em">Fix XSS Vulnerability (<a
+                            href="https://github.com/eclipse/hawkbit/pull/924">#924</a>)</li>
+                    <li style="margin-bottom: 0.5em">Management API supports SHA256 file hashes of artifacts (<a
+                            href="https://github.com/eclipse/hawkbit/pull/918">#918</a>)</li>
+                    <li style="margin-bottom: 0.5em">Add Stackoverflow tag for hawkBit (<a
+                            href="https://github.com/eclipse/hawkbit/issues/923">#923</a>)</li>
+                    <li style="margin-bottom: 0.5em">... and <a
+                            href="https://github.com/eclipse/hawkbit/pulls?utf8=✓&q=created%3A%3E%3D2019-10-25">many
+                            smaller enhancements and bug fixes </a></li>
+                </ul>
+            </section>
+
+            <section>
+                <h1>Current challenges and next steps</h1>
+                <ul style="position:absolute; left:2em;">
+
+                    <li style="margin-bottom: 0.5em">Release 0.3.0 (<a
+                            href="https://github.com/eclipse/hawkbit/issues/784">#784</a>)</li>
+                    <li style="margin-bottom: 0.5em">Update from EPL-1.0 to EPL-2.0 (<a
+                            href="https://github.com/eclipse/hawkbit/issues/1008">#1008</a>)</li>
+                    <li style="margin-bottom: 0.5em">Migrate hawkBit to Spring Boot 2.3.x (<a
+                            href="https://github.com/eclipse/hawkbit/issues/999">#999</a>)</li>
+                    <li style="margin-bottom: 0.5em">Integration with other device inventories (<a
+                            href="https://github.com/eclipse/hawkbit/issues/796">#796</a>)</li>
+                </ul>
+            </section>
+
+
+            <section>
+                <h1>Thank you</h1>
+                <div style="font-size: 1.5em; position:absolute; left:2em;">
+                    <p><i class="fab fa-gitter fa-fw"></i>&nbsp;<a
+                            href="https://gitter.im/eclipse/hawkbit">eclipse/hawkbit</a></p>
+                    <p><i class="fab fa-github fa-fw"></i>&nbsp;<a
+                            href="https://github.com/eclipse/hawkbit">eclipse/hawkbit</a></p>
+                    <p><i class="fa fa-book-open fa-fw"></i>&nbsp;<a
+                            href="http://www.eclipse.org/hawkbit">eclipse.org/hawkbit</a></p>
+                    <p><i class="fab fa-stack-overflow fa-fw"></i>&nbsp;<a
+                            href="https://stackoverflow.com/questions/tagged/eclipse-hawkbit">eclipse-hawkbit</a></p>
+                </div>
+            </section>
+        </div>
+    </div>
+    <div class="footer">
+        <a href="http://www.eclipse.org" target="_blank">Eclipse Foundation</a> |
+        <a href="http://www.eclipse.org/legal/privacy.php" target="_blank">Privacy Policy</a> |
+        <a href="http://www.eclipse.org/legal/termsofuse.php" target="_blank">Terms of Use</a> |
+        <a href="http://www.eclipse.org/legal/copyright.php" target="_blank">Copyright Agent</a> |
+        <a href="http://www.eclipse.org/legal" target="_blank">Legal</a>
+    </div>
+    <script src="lib/js/head.min.js"></script>
+    <script src="js/reveal.js"></script>
+
+    <script>
+        // Full list of configuration options available at:
+        // https://github.com/hakimel/reveal.js#configuration
+        Reveal.initialize({
+            controls: false,
+            progress: true,
+            history: true,
+            center: true,
+
+            transition: 'convex', // none/fade/slide/convex/concave/zoom
+
+            // Optional reveal.js plugins
+            dependencies: [{
+                src: 'lib/js/classList.js',
+                condition: function () {
+                    return !document.body.classList;
+                }
+            }, {
+                src: 'plugin/markdown/marked.js',
+                condition: function () {
+                    return !!document.querySelector('[data-markdown]');
+                }
+            }, {
+                src: 'plugin/markdown/markdown.js',
+                condition: function () {
+                    return !!document.querySelector('[data-markdown]');
+                }
+            }, {
+                src: 'plugin/highlight/highlight.js',
+                async: true,
+                condition: function () {
+                    return !!document.querySelector('pre code');
+                },
+                callback: function () {
+                    hljs.initHighlightingOnLoad();
+                }
+            }, {
+                src: 'plugin/zoom-js/zoom.js',
+                async: true
+            }, {
+                src: 'plugin/notes/notes.js',
+                async: true
+            }]
+        });
+
+        Reveal.configure({
+            slideNumber: true
+        });
+    </script>
+
+</body>
+
+</html>
diff --git a/tags/index.html b/tags/index.html
index 871f47f..b384ef7 100644
--- a/tags/index.html
+++ b/tags/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Tags - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -416,7 +416,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/tags/index.xml b/tags/index.xml
index a18788c..7fa1a39 100644
--- a/tags/index.xml
+++ b/tags/index.xml
@@ -1,14 +1,10 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
   <channel>
     <title>Tags on Eclipse hawkBit</title>
     <link>https://www.eclipse.org/hawkbit/tags/</link>
     <description>Recent content in Tags on Eclipse hawkBit</description>
     <generator>Hugo -- gohugo.io</generator>
-    <language>en-us</language>
-    
-	<atom:link href="https://www.eclipse.org/hawkbit/tags/index.xml" rel="self" type="application/rss+xml" />
-    
-    
+    <language>en-us</language><atom:link href="https://www.eclipse.org/hawkbit/tags/index.xml" rel="self" type="application/rss+xml" />
   </channel>
-</rss>
\ No newline at end of file
+</rss>
diff --git a/ui/index.html b/ui/index.html
index 8909f54..d7b4e6c 100644
--- a/ui/index.html
+++ b/ui/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>Management UI - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -652,7 +652,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
diff --git a/whatishawkbit/index.html b/whatishawkbit/index.html
index 1ec8336..aaf1799 100644
--- a/whatishawkbit/index.html
+++ b/whatishawkbit/index.html
@@ -10,7 +10,7 @@
     <meta name="viewport" content="width=device-width,user-scalable=no,initial-scale=1,maximum-scale=1">
     <meta http-equiv="X-UA-Compatible" content="IE=10" />
     <title>What is hawkBit? - Eclipse hawkBit</title>
-    <meta name="generator" content="Hugo 0.56.3" />
+    <meta name="generator" content="Hugo 0.77.0" />
 
     
     <meta name="description" content="IoT. Update. Device.">
@@ -462,7 +462,7 @@
   </div>
   <p class="notice">
     
-    &copy; 2020 The Eclipse hawkBit Project &ndash;
+    &copy; 2021 The Eclipse hawkBit Project &ndash;
     
     Documentation built with
     <a href="https://www.gohugo.io" target="_blank">Hugo</a>
