diff --git a/docs/pe/org.apache.streampipes.connect.adapters.coindesk.md b/docs/pe/org.apache.streampipes.connect.adapters.coindesk.md
new file mode 100644
index 0000000..26cd99b
--- /dev/null
+++ b/docs/pe/org.apache.streampipes.connect.adapters.coindesk.md
@@ -0,0 +1,44 @@
+---
+id: org.apache.streampipes.connect.adapters.coindesk
+title: Coindesk Bitcoin Price
+sidebar_label: Coindesk Bitcoin Price
+---
+
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~    http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  ~
+  -->
+
+
+
+<p align="center"> 
+    <img src="/img/pipeline-elements/org.apache.streampipes.connect.adapters.coindesk/icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
+***
+
+## Description
+This adapter continuously provides the current bitcoin price from the Coindesk API.
+
+## Configuration
+
+### Currency
+
+The current in which the price should be provided.
+
+
+***
+
diff --git a/docs/pe/org.apache.streampipes.connect.adapters.flic.mqtt.md b/docs/pe/org.apache.streampipes.connect.adapters.flic.mqtt.md
new file mode 100644
index 0000000..fa4a640
--- /dev/null
+++ b/docs/pe/org.apache.streampipes.connect.adapters.flic.mqtt.md
@@ -0,0 +1,59 @@
+---
+id: org.apache.streampipes.connect.adapters.flic.mqtt
+title: Flic MQTT
+sidebar_label: Flic MQTT
+---
+
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~    http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  ~
+  -->
+
+
+
+<p align="center"> 
+    <img src="/img/pipeline-elements/org.apache.streampipes.connect.adapters.flic.mqtt/icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
+***
+
+## Description
+
+Connect Flic Smart Button over MQTT
+
+***
+
+## Required input
+
+This adapter uses the MQTT protocol and requires the data in following exemplary JSON format:
+{ "timestamp": 1584973344615, "click_type": SINGLE, "button_id": button1 }.
+***
+
+## Configuration
+
+### Broker URL 
+
+Example: tcp://test-server.com:1883 (Protocol required. Port required)
+
+### Access Mode
+
+The user can choose between unauthenticated or authenticated access.
+
+### TOPIC
+The topic the MQTT broker publishes to.
+
+## Output
+
diff --git a/docs/pe/org.apache.streampipes.connect.adapters.image.stream.md b/docs/pe/org.apache.streampipes.connect.adapters.image.stream.md
new file mode 100644
index 0000000..a03806d
--- /dev/null
+++ b/docs/pe/org.apache.streampipes.connect.adapters.image.stream.md
@@ -0,0 +1,38 @@
+---
+id: org.apache.streampipes.connect.adapters.image.stream
+title: Image Upload (Stream)
+sidebar_label: Image Upload (Stream)
+---
+
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~    http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  ~
+  -->
+
+
+
+<p align="center"> 
+    <img src="/img/pipeline-elements/org.apache.streampipes.connect.adapters.image.stream/icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
+***
+
+## Description
+
+Upload a zip file of images and create an event per image
+
+***
+
diff --git a/docs/pe/org.apache.streampipes.connect.adapters.iss.md b/docs/pe/org.apache.streampipes.connect.adapters.iss.md
new file mode 100644
index 0000000..ab27d57
--- /dev/null
+++ b/docs/pe/org.apache.streampipes.connect.adapters.iss.md
@@ -0,0 +1,39 @@
+---
+id: org.apache.streampipes.connect.adapters.iss
+title: ISS Location
+sidebar_label: ISS Location
+---
+
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~    http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  ~
+  -->
+
+
+
+<p align="center"> 
+    <img src="/img/pipeline-elements/org.apache.streampipes.connect.adapters.iss/icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
+***
+
+## Description
+
+Shows the live position of the International Space Station (ISS), updated every two seconds.
+
+
+***
+
diff --git a/docs/pe/org.apache.streampipes.connect.adapters.slack.md b/docs/pe/org.apache.streampipes.connect.adapters.slack.md
new file mode 100644
index 0000000..6f38240
--- /dev/null
+++ b/docs/pe/org.apache.streampipes.connect.adapters.slack.md
@@ -0,0 +1,39 @@
+---
+id: org.apache.streampipes.connect.adapters.slack
+title: Slack
+sidebar_label: Slack
+---
+
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~    http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  ~
+  -->
+
+
+
+<p align="center"> 
+    <img src="/img/pipeline-elements/org.apache.streampipes.connect.adapters.slack/icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
+***
+
+## Description
+
+Subscribes to a Slack channel
+
+
+***
+
diff --git a/docs/pe/org.apache.streampipes.connect.adapters.ti.md b/docs/pe/org.apache.streampipes.connect.adapters.ti.md
new file mode 100644
index 0000000..c495db2
--- /dev/null
+++ b/docs/pe/org.apache.streampipes.connect.adapters.ti.md
@@ -0,0 +1,57 @@
+---
+id: org.apache.streampipes.connect.adapters.ti
+title: TI Sensor Tag
+sidebar_label: TI Sensor Tag
+---
+
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~    http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  ~
+  -->
+
+
+
+<p align="center"> 
+    <img src="/img/pipeline-elements/org.apache.streampipes.connect.adapters.ti/icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
+***
+
+## Description
+
+Consumes messages from a broker using the MQTT protocol
+
+
+***
+
+## Configuration
+
+Describe the configuration parameters here
+
+### Broker Url
+
+Example: tcp://test-server.com:1883 (Protocol required. Port required)"
+
+### Topic
+
+Example: test/topic
+
+### Access Mode
+
+Unauthenticated or Authenticated (Username/Password)
+
+## Output
+
diff --git a/docs/pe/org.apache.streampipes.connect.adapters.wikipedia.edit.md b/docs/pe/org.apache.streampipes.connect.adapters.wikipedia.edit.md
new file mode 100644
index 0000000..f0c0a5c
--- /dev/null
+++ b/docs/pe/org.apache.streampipes.connect.adapters.wikipedia.edit.md
@@ -0,0 +1,39 @@
+---
+id: org.apache.streampipes.connect.adapters.wikipedia.edit
+title: Wikipedia Edits
+sidebar_label: Wikipedia Edits
+---
+
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~    http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  ~
+  -->
+
+
+
+<p align="center"> 
+    <img src="/img/pipeline-elements/org.apache.streampipes.connect.adapters.wikipedia.edit/icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
+***
+
+## Description
+
+Continuously publishes recent Wikipedia edits
+
+
+***
+
diff --git a/docs/pe/org.apache.streampipes.connect.adapters.wikipedia.new.md b/docs/pe/org.apache.streampipes.connect.adapters.wikipedia.new.md
new file mode 100644
index 0000000..c041e11
--- /dev/null
+++ b/docs/pe/org.apache.streampipes.connect.adapters.wikipedia.new.md
@@ -0,0 +1,39 @@
+---
+id: org.apache.streampipes.connect.adapters.wikipedia.new
+title: Wikipedia New Articles
+sidebar_label: Wikipedia New Articles
+---
+
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~    http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  ~
+  -->
+
+
+
+<p align="center"> 
+    <img src="/img/pipeline-elements/org.apache.streampipes.connect.adapters.wikipedia.new/icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
+***
+
+## Description
+
+Continuously publishes articles created on Wikipedia
+
+
+***
+
diff --git a/docs/pe/org.apache.streampipes.connect.iiot.adapters.netio.mqtt.md b/docs/pe/org.apache.streampipes.connect.iiot.adapters.netio.mqtt.md
new file mode 100644
index 0000000..80cb041
--- /dev/null
+++ b/docs/pe/org.apache.streampipes.connect.iiot.adapters.netio.mqtt.md
@@ -0,0 +1,64 @@
+---
+id: org.apache.streampipes.connect.iiot.adapters.netio.mqtt
+title: NETIO MQTT M2M
+sidebar_label: NETIO MQTT M2M
+---
+
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~    http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  ~
+  -->
+
+
+
+<p align="center"> 
+    <img src="/img/pipeline-elements/org.apache.streampipes.connect.iiot.adapters.netio.mqtt/icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
+***
+
+## Description
+
+Connect Robots running on ROS
+
+
+***
+
+## Required input
+
+This sink does not have any requirements and works with any incoming event type.
+
+***
+
+## Configuration
+
+Describe the configuration parameters here
+
+### Ros Bridge
+
+Example: test-server.com (No protocol)
+
+### Port
+
+The port of the ROS instance.
+
+### Topic
+
+Example: /battery (Starts with /)
+
+
+## Output
+
diff --git a/docs/pe/org.apache.streampipes.connect.iiot.adapters.netio.rest.md b/docs/pe/org.apache.streampipes.connect.iiot.adapters.netio.rest.md
new file mode 100644
index 0000000..83c741e
--- /dev/null
+++ b/docs/pe/org.apache.streampipes.connect.iiot.adapters.netio.rest.md
@@ -0,0 +1,64 @@
+---
+id: org.apache.streampipes.connect.iiot.adapters.netio.rest
+title: NETIO http JSON
+sidebar_label: NETIO http JSON
+---
+
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~    http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  ~
+  -->
+
+
+
+<p align="center"> 
+    <img src="/img/pipeline-elements/org.apache.streampipes.connect.iiot.adapters.netio.rest/icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
+***
+
+## Description
+
+Connect Robots running on ROS
+
+
+***
+
+## Required input
+
+This sink does not have any requirements and works with any incoming event type.
+
+***
+
+## Configuration
+
+Describe the configuration parameters here
+
+### Ros Bridge
+
+Example: test-server.com (No protocol)
+
+### Port
+
+The port of the ROS instance.
+
+### Topic
+
+Example: /battery (Starts with /)
+
+
+## Output
+
diff --git a/docs/pe/org.apache.streampipes.processors.enricher.jvm.sizemeasure.md b/docs/pe/org.apache.streampipes.processors.enricher.jvm.sizemeasure.md
deleted file mode 100644
index cb49f5b..0000000
--- a/docs/pe/org.apache.streampipes.processors.enricher.jvm.sizemeasure.md
+++ /dev/null
@@ -1,49 +0,0 @@
----
-id: org.apache.streampipes.processors.enricher.jvm.sizemeasure
-title: Size Measure
-sidebar_label: Size Measure
----
-
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one or more
-  ~ contributor license agreements.  See the NOTICE file distributed with
-  ~ this work for additional information regarding copyright ownership.
-  ~ The ASF licenses this file to You under the Apache License, Version 2.0
-  ~ (the "License"); you may not use this file except in compliance with
-  ~ the License.  You may obtain a copy of the License at
-  ~
-  ~    http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License.
-  ~
-  -->
-
-
-
-<p align="center"> 
-    <img src="/img/pipeline-elements/org.apache.streampipes.processors.enricher.jvm.sizemeasure/icon.png" width="150px;" class="pe-image-documentation"/>
-</p>
-
-***
-
-## Description
-
-Measures the size of an incoming event and appends this number to the event by serializing it.
-
-***
-
-## Required input
-The size measure processor does not have any specific input requirements.
-
-***
-
-## Configuration
-
-You can specify if the size should be in Bytes, Kilobytes (1024 Bytes) or in Megabytes (1024 Kilobytes).
-
-## Output
-The size measure processor appends the size of the event (without the field, which is getting added) as a double. The rest of the event stays the same.
\ No newline at end of file
diff --git a/docs/pe/org.apache.streampipes.processors.textmining.jvm.languagedetection.md b/docs/pe/org.apache.streampipes.processors.textmining.jvm.languagedetection.md
deleted file mode 100644
index a3820ee..0000000
--- a/docs/pe/org.apache.streampipes.processors.textmining.jvm.languagedetection.md
+++ /dev/null
@@ -1,169 +0,0 @@
----
-id: org.apache.streampipes.processors.textmining.jvm.languagedetection
-title: Language Detection
-sidebar_label: Language Detection
----
-
-<!--
-  ~ Licensed to the Apache Software Foundation (ASF) under one or more
-  ~ contributor license agreements.  See the NOTICE file distributed with
-  ~ this work for additional information regarding copyright ownership.
-  ~ The ASF licenses this file to You under the Apache License, Version 2.0
-  ~ (the "License"); you may not use this file except in compliance with
-  ~ the License.  You may obtain a copy of the License at
-  ~
-  ~    http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License.
-  ~
-  -->
-
-
-
-<p align="center"> 
-    <img src="/img/pipeline-elements/org.apache.streampipes.processors.textmining.jvm.languagedetection/icon.png" width="150px;" class="pe-image-documentation"/>
-</p>
-
-***
-
-## Description
-
-Detects the language of incoming text. For a proper detection each text should contain at least 2 sentences.
-
-Supported languages:
-* Afrikaans (afr)
-* Arabic (ara)
-* Asturian (ast)
-* Azerbaijani (aze)
-* Bashkir (bak)
-* Belarusian (bel)
-* Bengali (ben)
-* Bosnian (bos)
-* Breton (bre)
-* Bulgarian (bul)
-* Catalan (cat)
-* Cebuano (ceb)
-* Czech (ces)
-* Chechen (che)
-* Mandarin Chinese (cmn)
-* Welsh (cym)
-* Danish (dan)
-* German (deu)
-* Standard Estonian (ekk)
-* Greek, Modern (ell)
-* English (eng)
-* Esperanto (epo)
-* Estonian (est)
-* Basque (eus)
-* Faroese (fao)
-* Persian (fas)
-* Finnish (fin)
-* French (fra)
-* Western Frisian (fry)
-* Irish (gle)
-* Galician (glg)
-* Swiss German (gsw)
-* Gujarati (guj)
-* Hebrew (heb)
-* Hindi (hin)
-* Croatian (hrv)
-* Hungarian (hun)
-* Armenian (hye)
-* Indonesian (ind)
-* Icelandic (isl)
-* Italian (ita)
-* Javanese (jav)
-* Japanese (jpn)
-* Kannada (kan)
-* Georgian (kat)
-* Kazakh (kaz)
-* Kirghiz (kir)
-* Korean (kor)
-* Latin (lat)
-* Latvian (lav)
-* Limburgan (lim)
-* Lithuanian (lit)
-* Luxembourgish (ltz)
-* Standard Latvian (lvs)
-* Malayalam (mal)
-* Marathi (mar)
-* Minangkabau (min)
-* Macedonian (mkd)
-* Maltese (mlt)
-* Mongolian (mon)
-* Maori (mri)
-* Malay (msa)
-* Min Nan Chinese (nan)
-* Low German (nds)
-* Nepali (nep)
-* Dutch (nld)
-* Norwegian Nynorsk (nno)
-* Norwegian Bokmål (nob)
-* Occitan (oci)
-* Panjabi (pan)
-* Iranian Persian (pes)
-* Plateau Malagasy (plt)
-* Western Panjabi (pnb)
-* Polish (pol)
-* Portuguese (por)
-* Pushto (pus)
-* Romanian (ron)
-* Russian (rus)
-* Sanskrit (san)
-* Sinhala (sin)
-* Slovak (slk)
-* Slovenian (slv)
-* Somali (som)
-* Spanish (spa)
-* Albanian (sqi)
-* Serbian (srp)
-* Sundanese (sun)
-* Swahili (swa)
-* Swedish (swe)
-* Tamil (tam)
-* Tatar (tat)
-* Telugu (tel)
-* Tajik (tgk)
-* Tagalog (tgl)
-* Thai (tha)
-* Turkish (tur)
-* Ukrainian (ukr)
-* Urdu (urd)
-* Uzbek (uzb)
-* Vietnamese (vie)
-* Volapük (vol)
-* Waray (war)
-* Zulu (zul)
-
-***
-
-## Required input
-
-A stream with a string property which contains a text.
-The longer the text, the higher the accuracy of the language detector.
-
-
-***
-
-## Configuration
-
-Simply assign the correct output of the previous stream to the language detector input.
-To use this component you have to download or train an openNLP model:
-https://opennlp.apache.org/models.html
-
-## Output
-
-Adds two fields to the event:
-1. String Property: The acronym of the detected language which can be seen above.
-2. Double Property: The confidence of the detector that it found the correct language. Between 0 (not certain at all) and 1 (very certain).
-
-
-**Example:**
-
-Input: `(text: "Hi, how are you?")`
-
-Output: `(text: "Hi, how are you?", language: "eng", confidenceLanguage: 0.89)`
diff --git a/website-v2/sidebars.json b/website-v2/sidebars.json
index 336ba93..21ab0e4 100644
--- a/website-v2/sidebars.json
+++ b/website-v2/sidebars.json
@@ -27,17 +27,27 @@
           "pe/org.apache.streampipes.connect.iiot.protocol.stream.pulsar",
           "pe/org.apache.streampipes.connect.iiot.protocol.stream.rocketmq",
           "pe/org.apache.streampipes.connect.iiot.protocol.stream.tubemq",
+          "pe/org.apache.streampipes.connect.adapters.coindesk",
           "pe/org.apache.streampipes.connect.iiot.protocol.stream.file",
+          "pe/org.apache.streampipes.connect.adapters.flic.mqtt",
           "pe/org.apache.streampipes.connect.iiot.protocol.stream.httpserver",
           "pe/org.apache.streampipes.connect.iiot.protocol.stream.http",
+          "pe/org.apache.streampipes.connect.adapters.iss",
+          "pe/org.apache.streampipes.connect.adapters.image.stream",
           "pe/org.apache.streampipes.connect.iiot.adapters.influxdb.stream",
           "pe/org.apache.streampipes.connect.iiot.protocol.stream.mqtt",
           "pe/org.apache.streampipes.connect.iiot.adapters.simulator.machine",
           "pe/org.apache.streampipes.connect.iiot.protocol.stream.nats",
+          "pe/org.apache.streampipes.connect.iiot.adapters.netio.mqtt",
+          "pe/org.apache.streampipes.connect.iiot.adapters.netio.rest",
           "pe/org.apache.streampipes.connect.iiot.adapters.opcua",
           "pe/org.apache.streampipes.connect.iiot.adapters.plc4x.modbus",
           "pe/org.apache.streampipes.connect.iiot.adapters.plc4x.s7",
           "pe/org.apache.streampipes.connect.iiot.adapters.ros",
+          "pe/org.apache.streampipes.connect.adapters.slack",
+          "pe/org.apache.streampipes.connect.adapters.ti",
+          "pe/org.apache.streampipes.connect.adapters.wikipedia.edit",
+          "pe/org.apache.streampipes.connect.adapters.wikipedia.new",
           "pe/org.apache.streampipes.connect.iiot.adapters.iolink"
         ]
       },
@@ -47,6 +57,7 @@
         "items": [
           "pe/org.apache.streampipes.processors.transformation.jvm.booloperator.counter",
           "pe/org.apache.streampipes.processors.filters.jvm.processor.booleanfilter",
+          "pe/org.apache.streampipes.processors.filters.jvm.processor.booleanfilter",
           "pe/org.apache.streampipes.processors.transformation.jvm.booloperator.inverter",
           "pe/org.apache.streampipes.processors.transformation.jvm.booloperator.logical",
           "pe/org.apache.streampipes.processors.transformation.jvm.booloperator.timer",
@@ -55,6 +66,7 @@
           "pe/org.apache.streampipes.processors.transformation.jvm.duration-value",
           "pe/org.apache.streampipes.processors.textmining.jvm.chunker",
           "pe/org.apache.streampipes.processors.filters.jvm.compose",
+          "pe/org.apache.streampipes.processors.filters.jvm.compose",
           "pe/org.apache.streampipes.processors.transformation.jvm.count-array",
           "pe/org.apache.streampipes.processors.siddhi.count",
           "pe/org.apache.streampipes.processors.transformation.jvm.fieldhasher",
@@ -78,38 +90,48 @@
           "pe/org.apache.streampipes.processor.imageclassification.jvm.image-cropper",
           "pe/org.apache.streampipes.processor.imageclassification.jvm.image-enricher",
           "pe/org.apache.streampipes.processors.enricher.jvm.jseval",
-          "pe/org.apache.streampipes.processors.textmining.jvm.languagedetection",
           "pe/org.apache.streampipes.processors.siddhi.listcollector",
           "pe/org.apache.streampipes.processors.siddhi.listfilter",
           "pe/org.apache.streampipes.processors.enricher.jvm.processor.math.mathop",
           "pe/org.apache.streampipes.processors.transformation.jvm.booloperator.timekeeping",
           "pe/org.apache.streampipes.processors.transformation.jvm.measurementunitconverter",
           "pe/org.apache.streampipes.processors.filters.jvm.enrich",
+          "pe/org.apache.streampipes.processors.filters.jvm.enrich",
           "pe/org.apache.streampipes.processors.filters.jvm.schema",
+          "pe/org.apache.streampipes.processors.filters.jvm.schema",
+          "pe/org.apache.streampipes.processors.filters.jvm.movingaverage",
           "pe/org.apache.streampipes.processors.filters.jvm.movingaverage",
           "pe/org.apache.streampipes.processors.textmining.jvm.namefinder",
           "pe/org.apache.streampipes.processors.transformation.jvm.processor.state.labeler.number",
           "pe/org.apache.streampipes.processors.transformation.jvm.round",
           "pe/org.apache.streampipes.processors.filters.jvm.numericalfilter",
+          "pe/org.apache.streampipes.processors.filters.jvm.numericalfilter",
           "pe/org.apache.streampipes.processors.siddhi.numericalfilter",
           "pe/org.apache.streampipes.processors.filters.jvm.numericaltextfilter",
+          "pe/org.apache.streampipes.processors.filters.jvm.numericaltextfilter",
           "pe/org.apache.streampipes.processors.textmining.jvm.partofspeech",
           "pe/org.apache.streampipes.processors.filters.jvm.project",
+          "pe/org.apache.streampipes.processors.filters.jvm.project",
           "pe/org.apache.streampipes.processor.imageclassification.qrcode",
           "pe/org.apache.streampipes.processors.filters.jvm.limit",
+          "pe/org.apache.streampipes.processors.filters.jvm.limit",
           "pe/org.apache.streampipes.processors.textmining.jvm.sentencedetection",
           "pe/org.apache.streampipes.processors.transformation.jvm.processor.booloperator.edge",
-          "pe/org.apache.streampipes.processors.enricher.jvm.sizemeasure",
           "pe/org.apache.streampipes.processors.transformation.jvm.split-array",
           "pe/org.apache.streampipes.processors.enricher.jvm.processor.math.staticmathop",
           "pe/org.apache.streampipes.processors.transformation.jvm.stringoperator.counter",
           "pe/org.apache.streampipes.processors.transformation.jvm.stringoperator.timer",
           "pe/org.apache.streampipes.processors.transformation.jvm.processor.stringoperator.state",
           "pe/org.apache.streampipes.processors.filters.jvm.sdt",
+          "pe/org.apache.streampipes.processors.filters.jvm.sdt",
+          "pe/org.apache.streampipes.processors.filters.jvm.merge",
           "pe/org.apache.streampipes.processors.filters.jvm.merge",
           "pe/org.apache.streampipes.processors.transformation.jvm.taskduration",
           "pe/org.apache.streampipes.processors.filters.jvm.textfilter",
+          "pe/org.apache.streampipes.processors.filters.jvm.textfilter",
           "pe/org.apache.streampipes.processors.filters.jvm.threshold",
+          "pe/org.apache.streampipes.processors.filters.jvm.threshold",
+          "pe/org.apache.streampipes.processors.filters.jvm.throughputmon",
           "pe/org.apache.streampipes.processors.filters.jvm.throughputmon",
           "pe/org.apache.streampipes.processors.transformation.jvm.processor.timestampextractor",
           "pe/org.apache.streampipes.processors.textmining.jvm.tokenizer",
@@ -191,4 +213,4 @@
       "faq-common-problems"
     ]
   }
-}
+}
\ No newline at end of file
diff --git a/website-v2/static/img/pipeline-elements/org.apache.streampipes.connect.iiot.adapters.netio.mqtt/icon.png b/website-v2/static/img/pipeline-elements/org.apache.streampipes.connect.iiot.adapters.netio.mqtt/icon.png
new file mode 100644
index 0000000..b202048
--- /dev/null
+++ b/website-v2/static/img/pipeline-elements/org.apache.streampipes.connect.iiot.adapters.netio.mqtt/icon.png
Binary files differ
diff --git a/website-v2/static/img/pipeline-elements/org.apache.streampipes.connect.iiot.adapters.netio.rest/icon.png b/website-v2/static/img/pipeline-elements/org.apache.streampipes.connect.iiot.adapters.netio.rest/icon.png
new file mode 100644
index 0000000..b202048
--- /dev/null
+++ b/website-v2/static/img/pipeline-elements/org.apache.streampipes.connect.iiot.adapters.netio.rest/icon.png
Binary files differ
