add missing version 0.70.0 files
diff --git a/documentation/website/versioned_docs/version-0.70.0/01_try-installation.md b/documentation/website/versioned_docs/version-0.70.0/01_try-installation.md
new file mode 100644
index 0000000..e625b21
--- /dev/null
+++ b/documentation/website/versioned_docs/version-0.70.0/01_try-installation.md
@@ -0,0 +1,136 @@
+---
+id: version-0.70.0-try-installation
+title: Installation
+sidebar_label: Installation
+original_id: try-installation
+---
+
+The easiest way to install StreamPipes is our Docker-based installation. For production-grade deployments, we also
+recommend looking at our Kubernetes support, which is also part of the installation kit.
+
+## Prerequisites
+
+The Docker-based installation requires **Docker** and **Docker Compose** to be installed on the target machine.
+Installation instructions can be found below.
+
+<div class="admonition info">
+<div class="admonition-title">Install Docker</div>
+<p>Go to https://docs.docker.com/installation/ and follow the instructions to install Docker for your OS. Make sure docker can be started as a non-root user (described in the installation manual, don’t forget to log out and in again) and check that Docker is installed correctly by executing docker-run hello-world</p>
+</div>
+
+<div class="admonition info">
+<div class="admonition-title">Configure Docker</div>
+<p>By default, Docker uses only a limited number of CPU cores and memory.
+ If you run StreamPipes on Windows or on a Mac you need to adjust the default settings.
+ To do that, click on the Docker icon in your tab bar and open the preferences.
+ Go to the advanced preferences and set the **number of CPUs to 6** (recommended) and the **Memory to 4GB**.
+ After changing the settings, Docker needs to be restarted.</p></div>
+
+### Supported operating systems
+
+The Docker-based installation supports the operating systems **Linux**, **Mac OS X** and **Windows 10**. Older windows
+versions are not fully compatible with Docker. Linux VMs running under Windows might cause network problems with Docker,
+therefore some manual work might be needed to make StreamPipes run properly.
+
+### Web Browser
+
+The StreamPipes application itself will be accessible through a web browser. We recommend a recent version of Chrome (
+best experience), Firefox or Edge.
+
+## Install StreamPipes
+
+<ul style="padding-left:0">
+ <li class="installation-step" style="margin-top:20px;">
+ <div class="wrapper-container" style="">
+ <div class="wrapper-step">
+ <span class="fa-stack fa-2x">
+ <i class="fas fa-circle fa-stack-2x sp-color-green"></i>
+ <strong class="fa-stack-1x" style="color:white;">1</strong>
+ </span>
+ </div>
+ <div class="wrapper-instruction">
+ Download the latest Apache StreamPipes release and extract the zip file to a directory of your choice.
+ <table class="table" style="margin-top:30px;">
+ <thead>
+ <tr style="background:rgb(27, 20, 100);color:white;">
+ <th scope="col" style="border-bottom:0px;border-top:0px;">File</th>
+ <th scope="col" style="border-bottom:0px;border-top:0px;">Version</th>
+ <th scope="col" style="border-bottom:0px;border-top:0px;">Release Date</th>
+ <th scope="col" style="border-bottom:0px;border-top:0px;">Signatures</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <td><a href="https://www.apache.org/dyn/mirrors/mirrors.cgi?action=download&filename=incubator/streampipes/0.70.0/apache-streampipes-0.70.0-incubating-source-release.zip">apache-streampipes-0.70.0-incubating-source-release.zip</a></td>
+ <td>0.70.0</td>
+ <td>2022-10-13</td>
+ <td>
+ <a href="https://downloads.apache.org/incubator/streampipes/0.70.0/apache-streampipes-0.70.0-incubating-source-release.zip.sha512">SHA</a>
+ <a href="https://downloads.apache.org/incubator/streampipes/0.70.0/apache-streampipes-0.70.0-incubating-source-release.zip.asc">PGP</a>
+ </td>
+ </tr>
+ </tbody>
+ </table>
+ <div class="row">
+ <div class="alert alert-info" role="alert">
+ The above release file should be verified using the PGP signatures and the <a href="https://downloads.apache.org/incubator/streampipes/KEYS">project release KEYS</a>. See the official ASF <a target="asf" href="https://www.apache.org/dyn/closer.cgi#verify">verification instructions</a> for a description of using the PGP and KEYS files for verification. A SHA512 checksum is also provided as an additional verification method.
+ </div>
+ </div>
+ </div>
+ </div>
+ </li>
+ <li class="installation-step">
+ <div class="wrapper-container">
+ <div class="wrapper-step">
+ <span class="fa-stack fa-2x">
+ <i class="fas fa-circle fa-stack-2x sp-color-green"></i>
+ <strong class="fa-stack-1x" style="color:white;">2</strong>
+ </span>
+ </div>
+ <div class="wrapper-instruction">
+ <div style="margin-bottom:5px;">In a command prompt, open the folder <code>installer/compose</code> and run <code>docker-compose up -d</code>.
+
+ </div>
+ </div>
+ </div>
+ </li>
+ <li class="installation-step">
+ <div class="wrapper-container" style="align-items: center;justify-content: center;">
+ <div class="wrapper-step">
+ <span class="fa-stack fa-2x">
+ <i class="fas fa-circle fa-stack-2x sp-color-green"></i>
+ <strong class="fa-stack-1x" style="color:white;">3</strong>
+ </span>
+ </div>
+ <div class="wrapper-instruction">
+ Open your browser, navigate to http://localhost:80 (or the domain name of your server) and log in using the default email <code>admin@streampipes.apache.org</code> and default password <code>admin</code>.
+ </div>
+ </div>
+ </li>
+</ul>
+
+## Setup StreamPipes
+
+Once you've opened the browser at the URL given above, you should see the StreamPipes application as shown below. At initial startup, StreamPipes automatically performs an installation process.
+After the installation has finished, continue by clicking on "Go to login
+page", once all components are successfully configured.
+
+On the login page, enter your credentials, then you should be forwarded to the home page.
+
+Congratulations! You've successfully managed to install StreamPipes. Now we're ready to build our first pipeline!
+
+<div class="my-carousel docs-carousel">
+ <img src="/docs/img/01_try-installation/03_login.png" alt="Go to login page">
+ <img src="/docs/img/01_try-installation/04_home.png" alt="Home page">
+</div>
+
+<div class="admonition error">
+<div class="admonition-title">Errors during the installation process</div>
+<p>In most cases, errors during the installation are due to an under-powered system.<br/>
+If there is a problem with any of the components, please restart the whole system (<code>docker-compose down</code> and eventually also delete the volumes).
+ Please also make sure that your system meets the hardware requirements as mentioned in the first section of the installation guide.</p>
+</div>
+
+## Next Steps
+
+That's it! To ease your first steps with StreamPipes, we've created an [interactive tutorial](01_try-tutorial.md).
diff --git a/documentation/website/versioned_docs/version-0.70.0/06_extend-setup.md b/documentation/website/versioned_docs/version-0.70.0/06_extend-setup.md
new file mode 100644
index 0000000..17fb0e0
--- /dev/null
+++ b/documentation/website/versioned_docs/version-0.70.0/06_extend-setup.md
@@ -0,0 +1,51 @@
+---
+id: version-0.70.0-extend-setup
+title: Development Setup
+sidebar_label: Development Setup
+original_id: extend-setup
+---
+
+Pipeline elements in StreamPipes are provided as standalone microservices. New pipeline elements can be easily developed using the provided Maven archetypes and can be installed in StreamPipes at runtime.
+
+In this section, we describe our recommended minimum setup for locally setting up a development instance of StreamPipes needed to develop, run and test new pipeline elements.
+
+## IDE & required dev tools
+StreamPipes does not have specific requirements on the IDE - so feel free to choose the IDE of your choice.
+The only requirements in terms of development tools are that you have Java 8 and Maven installed.
+
+## StreamPipes CLI: Docker-based local StreamPipes instance
+In order to quickly test developed pipeline elements without needing to install all services required by StreamPipes, we provide a CLI tool that allows you to selectively start StreamPipes components.
+The CLI tool allows to switch to several templates (based on docker-compose) depending on the role.
+
+The documentation on the usage of the CLI tool is available [here](06_extend-cli.md).
+
+## Override the SP_HOST variable
+
+By default, the backend/core of StreamPipes registers itself within StreamPipes' service discovery mechanism using an auto-discovered hostname.
+Usually, this will be an IP address from the Docker network, which is not resolvable from outside. Therefore, for local development you need to override the hostname with an IP address which is accessible from your local host where you develop extensions.
+When using the CLI, open the CLI folder ``installer/cli``, navigate to ``deploy/standalone/backend``, open the ``docker-compose.dev.yml`` file and add the SP_HOST env variable, e.g.
+
+```
+version: "3.4"
+services:
+ backend:
+ ports:
+ - "8030:8030"
+ environment:
+ - SP_HOST=host.docker.internal
+```
+
+Note that host.docker.internal will work as an alias under Docker for Desktop on Windows and Mac, but not on Linux or M1. In this case, provide a resolvable hostname or IP address manually.
+
+## Starter projects
+
+Now, once you've started the development instance, you are ready to develop your very first pipeline element.
+Instead of starting from scratch, we recommend using our provided maven archetypes:
+
+### Maven archetypes
+
+Create the Maven archetype as described in the [Maven Archetypes](06_extend-archetypes.md) guide.
+
+### Examples
+
+We provide several examples that explain the usage of some concepts in this [Github repo](https://github.com/apache/incubator-streampipes-examples).
diff --git a/documentation/website/versioned_docs/version-0.70.0/06_extend-tutorial-data-sources.md b/documentation/website/versioned_docs/version-0.70.0/06_extend-tutorial-data-sources.md
new file mode 100644
index 0000000..a844100
--- /dev/null
+++ b/documentation/website/versioned_docs/version-0.70.0/06_extend-tutorial-data-sources.md
@@ -0,0 +1,214 @@
+---
+id: version-0.70.0-extend-tutorial-data-sources
+title: Tutorial: Data Sources
+sidebar_label: Tutorial: Data Sources
+original_id: extend-tutorial-data-sources
+---
+
+In this tutorial, we will add a new data source consisting of a single data stream. The source will be provided as a standalone component (i.e., the description will be accessible through an integrated web server).
+
+## Objective
+
+We are going to create a new data stream that is produced by a GPS sensor installed in a delivery vehicle.
+The sensor produces a continuous stream of events that contain the current timestamp, the current lat/lng position of the vehicle and the plate number of the vehicle.
+Events are published in a JSON format as follows:
+```json
+{
+ "timestamp" : 145838399,
+ "latitude" : 37.04,
+ "longitude" : 17.04,
+ "plateNumber" : "KA-AB 123"
+}
+```
+
+These events are published to a Kafka broker using the topic `org.streampipes.tutorial.vehicle`.
+
+In the following section, we show how to describe this stream in a form that allows you to import and use it in StreamPipes.
+
+## Project setup
+
+Instead of creating a new project from scratch, we recommend to use the Maven archetype to create a new project skeleton (streampipes-archetype-extensions-jvm).
+Enter the following command in a command line of your choice (Apache Maven needs to be installed):
+
+```
+mvn archetype:generate \
+-DarchetypeGroupId=org.apache.streampipes -DarchetypeArtifactId=streampipes-archetype-extensions-jvm \
+-DarchetypeVersion=0.69.0 -DgroupId=my.groupId \
+-DartifactId=my-source -DclassNamePrefix=MySource -DpackageName=mypackagename
+```
+
+You will see a project structure similar to the structure shown in the [archetypes](06_extend-archetypes.md) section.
+
+<div class="admonition tip">
+<div class="admonition-title">Tip</div>
+<p>Besides the basic project skeleton, the sample project also includes an example Dockerfile you can use to package your application into a Docker container.
+</p>
+</div>
+
+## Adding a data stream description
+
+Now we will add a new data stream definition.
+First, create a new class `MyVehicleStream` which should look as follows:
+
+```java
+
+package org.apache.streampipes.pe.example;
+
+import org.apache.streampipes.model.SpDataStream;
+import org.apache.streampipes.sources.AbstractAdapterIncludedStream;
+
+public class MyVehicleStream extends AbstractAdapterIncludedStream {
+
+ @Override
+ public SpDataStream declareModel() {
+ return null;
+ }
+
+ @Override
+ public void executeStream() {
+
+ }
+}
+```
+
+This class extends the class ``AbstractAdapterIncludedStream``, which indicates that this source continuously produces data (configured in the ``executeStream()`` method.
+In contrast, the class `AbstractAlreadyExistingStream` indicates that we only want to describe an already existing stream (e.g., a stream that already sends data to an existing Kafka broker).
+
+Next, we will add the definition of the data stream. Add the following code inside of the `declareModel` method:
+```java
+return DataStreamBuilder.create("org.streampipes.tutorial.vehicle.position", "Vehicle Position", "An event stream " +
+ "that produces current vehicle positions")
+```
+
+This line creates a new instance of the SDK's `DataStreamBuilder` by providing three basic parameters:
+The first parameter must be a unique identifier of your data stream.
+The second and third parameters indicate a label and a description of your stream.
+These values will later be used in the StreamPipes UI to display stream details in a human-readable manner.
+
+Next, we will add the properties as stated above to the stream definition by adding the following lines:
+```java
+.property(EpProperties.timestampProperty("timestamp"))
+.property(EpProperties.stringEp(Labels.from("plate-number", "Plate Number", "Denotes the plate number of the vehicle"), "plateNumber", "http://my.company/plateNumber"))
+.property(EpProperties.doubleEp(Labels.from("latitude", "Latitude", "Denotes the latitude value of the vehicle's position"), "latitude", Geo.lat))
+.property(EpProperties.doubleEp(Labels.from("longitude", "Longitude", "Denotes the longitude value of the vehicle's position"), "longitude", Geo.lng))
+```
+These four _event properties_ compose our _event schema_. An event property must, at least, provide the following attributes:
+
+* **Runtime Name**. The runtime name indicates the key of the property at runtime, e.g., if our JSON message contains a structure such as `{"plateNumber" : "KA-F 123"}`, the runtime name must be `plateNumber`.
+* **Runtime Type**. An event property must have a primitive type (we will later see how to model more complex properties such as lists and nested properties).
+ The type must be an instance of `XMLSchema` primitives, however, the SDK provides convenience methods to provide the property type.
+* **Domain Property**. The domain property indicates the semantics of the event property. For instance, the `latitude` property is linked to the `http://www.w3.org/2003/01/geo/wgs84_pos#lat` property of the WGS84 vocabulary.
+ The domain property should be an URI as part of an existing or domain-specific vocabulary. The SDK provides convenience methods for popuplar vocabularies (e.g., Schema.org, Dolce or WGS84).
+
+In order to complete the minimum required specification of an event stream, we need to provide information on the transport format and protocol of the data stream at runtime.
+
+This can be achieved by extending the builder with the respective properties:
+```java
+.format(Formats.jsonFormat())
+.protocol(Protocols.kafka("localhost", 9094, "TOPIC_SHOULD_BE_CHANGED"))
+.build();
+```
+
+Set ``org.streampipes.tutorial.vehicle`` as your new topic by replacing the term ``TOPIC_SHOULD_BE_CHANGED`.
+
+In this example, we defined that the data stream consists of events in a JSON format and that Kafka is used as a message broker to transmit events.
+The last build() method call triggers the construction of the data stream definition.
+
+That's it! In the next section, we will connect the data stream to a source and inspect the generated RDF description.
+
+## Creating some dummy data
+
+Let's assume our stream should produce some random values that are sent to StreamPipes. We'll add a very simple data simulator to the ``executeStream`` method as follows:
+
+```java
+@Override
+ public void executeStream() {
+
+ SpKafkaProducer producer = new SpKafkaProducer("localhost:9094", "my-topic", Collections.emptyList());
+ Random random = new Random();
+ Runnable runnable = () -> {
+ for (;;) {
+ JsonObject jsonObject = new JsonObject();
+ jsonObject.addProperty("timestamp", System.currentTimeMillis());
+ jsonObject.addProperty("plateNumber", "KA-FZ 1");
+ jsonObject.addProperty("latitude", random.nextDouble());
+ jsonObject.addProperty("longitude", random.nextDouble());
+
+ producer.publish(jsonObject.toString());
+
+ try {
+ TimeUnit.SECONDS.sleep(1);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+
+ }
+ };
+
+ new Thread(runnable).start();
+ }
+```
+
+Change the topic and the URL of your Kafka broker (as stated in the controller).
+
+## Registering the data stream
+
+You need to register the stream in the service definition. Open the ``Init`` class and register the ``MyVehicleStream``:
+
+```java
+
+ @Override
+ public SpServiceDefinition provideServiceDefinition() {
+ return SpServiceDefinitionBuilder.create("org.apache.streampipes",
+ "human-readable service name",
+ "human-readable service description", 8090)
+ .registerPipelineElement(new ExampleDataProcessor())
+ .registerPipelineElement(new ExampleDataSink())
+ .registerPipelineElement(new MyVehicleStream())
+ .registerMessagingFormats(
+ new JsonDataFormatFactory(),
+ new CborDataFormatFactory(),
+ new SmileDataFormatFactory(),
+ new FstDataFormatFactory())
+ .registerMessagingProtocols(
+ new SpKafkaProtocolFactory(),
+ new SpJmsProtocolFactory(),
+ new SpMqttProtocolFactory())
+ .build();
+ }
+
+```
+
+You can remove the other two example classes if you want.
+
+## Starting the service
+
+<div class="admonition tip">
+<div class="admonition-title">Tip</div>
+<p>Once you start the service, it will register in StreamPipes with the hostname. The hostname will be auto-discovered and should work out-of-the-box.
+In some cases, the detected hostname is not resolvable from within a container (where the core is running). In this case, provide a SP_HOST environment variable to override the auto-discovery.
+</p>
+</div>
+
+Now we are ready to start our first container!
+
+Execute the main method in the class `Init`, open a web browser and navigate to http://localhost:8090, or change the port according to the value of the ``SP_PORT`` variable in the env file.
+
+Configure your IDE to provide an environment variable called ``SP_DEBUG`` with value ``true`` when starting the project.
+
+You should see something as follows:
+
+<img src="/docs/img/tutorial-sources/pe-overview.PNG" alt="Pipeline Element Container Overview">
+
+Click on the link of the data source to see the generated description of the pipeline element.
+
+<img src="/docs/img/tutorial-sources/pe-rdf.PNG" alt="Pipeline Element description">
+
+The container automatically registers itself in StreamPipes.
+
+To install the just created element, open the StreamPipes UI and install the source over the ``Install Pipeline Elements`` section.
+
+## Read more
+
+Congratulations! You've just created your first pipeline element for StreamPipes.
+There are many more things to explore and data sources can be defined in much more detail.
