You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@streampipes.apache.org by ri...@apache.org on 2025/05/21 10:52:15 UTC

(streampipes) branch dev updated: docs: Update documentation of processors and adapters (#3614)

This is an automated email from the ASF dual-hosted git repository.

riemer pushed a commit to branch dev
in repository https://gitbox.apache.org/repos/asf/streampipes.git


The following commit(s) were added to refs/heads/dev by this push:
     new 6d8546aa03 docs: Update documentation of processors and adapters (#3614)
6d8546aa03 is described below

commit 6d8546aa03e57e3cb7a13cf1f7ed89dfb2402524
Author: Dominik Riemer <do...@gmail.com>
AuthorDate: Wed May 21 12:52:10 2025 +0200

    docs: Update documentation of processors and adapters (#3614)
    
    * docs: Update documentation of transformation processors
    
    * Update docs in processors-filters module
    
    * Update docs in enricher module
    
    * Update docs in processors-siddhi module
    
    * Update docs for kafka and mqtt
---
 .../documentation.md                               |  52 ++++++-
 .../documentation.md                               |  74 ++++++++--
 .../documentation.md                               |  57 ++++++--
 .../documentation.md                               |  81 +++++++++--
 .../documentation.md                               | 100 ++++++++++++-
 .../documentation.md                               |  85 +++++++++--
 .../documentation.md                               |  85 +++++++++--
 .../documentation.md                               |  83 +++++++++--
 .../documentation.md                               |  76 ++++++++--
 .../documentation.md                               |  73 +++++++++-
 .../documentation.md                               |  83 ++++++++++-
 .../documentation.md                               |  85 ++++++++++-
 .../documentation.md                               |  91 +++++++++++-
 .../documentation.md                               | 119 +++++++++++++---
 .../documentation.md                               |  89 ++++++++++--
 .../documentation.md                               |  99 +++++++++++--
 .../documentation.md                               | 119 ++++++++++++++--
 .../documentation.md                               | 107 ++++++++++----
 .../documentation.md                               |  78 ++++++++++-
 .../documentation.md                               |  72 +++++++++-
 .../documentation.md                               |  96 +++++++++++--
 .../documentation.md                               |  73 +++++++++-
 .../documentation.md                               |  81 +++++++++--
 .../documentation.md                               |  90 ++++++++++--
 .../documentation.md                               |  89 +++++++++---
 .../documentation.md                               |  80 +++++++++--
 .../documentation.md                               |  88 +++++++++---
 .../documentation.md                               |  96 ++++++++++---
 .../documentation.md                               |  75 ++++++++--
 .../documentation.md                               |  67 +++++++--
 .../documentation.md                               |   2 +-
 .../documentation.md                               |  70 ++++++++--
 .../documentation.md                               | 112 +++++++++++++--
 .../documentation.md                               | 155 ++++++++++++++++++---
 .../documentation.md                               |  96 ++++++++++++-
 .../documentation.md                               | 155 ++++++++++++++++++++-
 .../documentation.md                               | 121 +++++++++++++---
 .../documentation.md                               | 126 +++++++++++++++--
 .../documentation.md                               |  91 +++++++++++-
 .../documentation.md                               |  68 ++++++++-
 .../documentation.md                               | 129 ++++++++++++-----
 .../documentation.md                               |  98 +++++++++----
 .../documentation.md                               |  88 +++++++++++-
 .../documentation.md                               |  94 ++++++++++---
 .../documentation.md                               |  62 ++++++++-
 .../documentation.md                               |  87 ++++++++++--
 .../documentation.md                               | 102 +++++++++++++-
 .../documentation.md                               | 152 ++++++++++++++++++--
 .../documentation.md                               | 131 +++++++++++++++--
 .../documentation.md                               |  85 +++++++++--
 .../documentation.md                               | 110 ++++++++++++---
 .../documentation.md                               |  88 ++++++++++--
 .../documentation.md                               | 123 ++++++++++++----
 .../documentation.md                               |  75 +++++++++-
 .../documentation.md                               | 112 ++++++++++++++-
 .../documentation.md                               | 107 +++++++++++---
 .../documentation.md                               | 108 ++++++++++++--
 .../documentation.md                               | 107 +++++++++++---
 .../documentation.md                               |  93 +++++++++++--
 .../documentation.md                               | 110 ++++++++++++++-
 .../documentation.md                               |  71 +++++++++-
 61 files changed, 4962 insertions(+), 709 deletions(-)

diff --git a/streampipes-extensions/streampipes-connectors-kafka/src/main/resources/org.apache.streampipes.connect.iiot.protocol.stream.kafka/documentation.md b/streampipes-extensions/streampipes-connectors-kafka/src/main/resources/org.apache.streampipes.connect.iiot.protocol.stream.kafka/documentation.md
index 7b261eda98..d9a5e0e1c3 100644
--- a/streampipes-extensions/streampipes-connectors-kafka/src/main/resources/org.apache.streampipes.connect.iiot.protocol.stream.kafka/documentation.md
+++ b/streampipes-extensions/streampipes-connectors-kafka/src/main/resources/org.apache.streampipes.connect.iiot.protocol.stream.kafka/documentation.md
@@ -16,7 +16,7 @@
   ~
   -->
 
-## Apache Kafka
+## Apache Kafka Adapter
 
 <p align="center"> 
     <img src="icon.png" width="150px;" class="pe-image-documentation"/>
@@ -25,8 +25,54 @@
 ***
 
 ## Description
-
-Consumes messages from an Apache Kafka broker
+The Apache Kafka protocol adapter enables StreamPipes to connect to Kafka brokers and consume messages. It provides:
+* Real-time message consumption from Kafka topics
+* Dynamic topic selection with runtime resolution
+* Support for both simple and wildcard topic subscriptions
+* Configurable consumer group settings
+* Multiple security options including SSL/TLS and SASL authentication
+* Configurable message handling and offset management
 
 ***
 
+## Configuration
+
+### Broker Settings
+* **Broker Hostname**: The hostname or IP address of the Kafka broker (e.g., test.server.com). Do not include the protocol.
+* **Broker Port**: The port number of the Kafka broker (default: 9092)
+
+### Security Settings
+* **Security Protocol**: Choose the security protocol for broker communication:
+  * `PLAINTEXT`: No authentication and plaintext communication
+  * `SSL`: Using SSL with no authentication
+  * `SASL/PLAINTEXT`: SASL authentication without encryption
+  * `SASL/SSL`: SASL authentication with SSL encryption
+
+* **Authentication** (when using SASL):
+  * **Security Mechanism**: Choose the SASL mechanism:
+    * `PLAIN`: Simple username/password authentication
+    * `SCRAM-SHA-256`: SCRAM authentication with SHA-256
+    * `SCRAM-SHA-512`: SCRAM authentication with SHA-512
+  * **Username**: SASL authentication username
+  * **Password**: SASL authentication password
+
+### Topic Settings
+* **Topic**: Select a Kafka topic to subscribe to. The list of available topics is dynamically loaded from the broker.
+* **Hide Internal Topics**: Option to hide topics that are only used internally by Kafka (e.g., topics starting with `__`)
+
+### Consumer Settings
+* **Consumer Group**: Configure how to handle consumer group ID:
+  * `Random group id`: StreamPipes generates a random group ID (recommended for testing)
+  * `Custom group id`: Specify a custom group ID for production use
+
+* **Auto Offset Reset**: Configure where to start reading messages:
+  * `Earliest`: Start reading from the earliest available messages
+  * `Latest`: Start reading from the latest messages
+  * `None`: Throw exceptions if no offset is available
+
+* **Additional Configurations**: Add custom Kafka consumer configurations in key=value format. Each configuration should be on a new line.
+
+### Advanced Settings
+* **Message Max Bytes**: Maximum size of messages to consume (default: 52428800 bytes)
+* **Session Timeout**: Consumer session timeout in milliseconds (default: 30000)
+* **Auto Commit Interval**: Interval for committing offsets in milliseconds (default: 5000)
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-connectors-kafka/src/main/resources/org.apache.streampipes.sinks.brokers.jvm.kafka/documentation.md b/streampipes-extensions/streampipes-connectors-kafka/src/main/resources/org.apache.streampipes.sinks.brokers.jvm.kafka/documentation.md
index 14b2b66e25..dedad0a352 100644
--- a/streampipes-extensions/streampipes-connectors-kafka/src/main/resources/org.apache.streampipes.sinks.brokers.jvm.kafka/documentation.md
+++ b/streampipes-extensions/streampipes-connectors-kafka/src/main/resources/org.apache.streampipes.sinks.brokers.jvm.kafka/documentation.md
@@ -25,32 +25,78 @@
 ***
 
 ## Description
-
-Publishes events to Apache Kafka.
+The Kafka Publisher sink enables StreamPipes to publish events to Apache Kafka topics. It provides:
+* Real-time event publishing to Kafka topics
+* Support for various security configurations
+* Automatic topic creation if not exists
+* Configurable message handling
+* JSON message serialization
 
 ***
 
-## Required input
-
-This sink does not have any requirements and works with any incoming event type.
+## Required Input
+This sink accepts any incoming event type and serializes it to JSON format before publishing to Kafka.
 
 ***
 
 ## Configuration
 
-### Kafka Broker Settings
+### Broker Settings
+* **Broker Hostname**: The hostname or IP address of the Kafka broker (e.g., test.server.com). Do not include the protocol.
+* **Broker Port**: The port number of the Kafka broker (default: 9092)
+
+### Security Settings
+* **Security Protocol**: Choose the security protocol for broker communication:
+  * `PLAINTEXT`: No authentication and plaintext communication
+  * `SSL`: Using SSL with no authentication
+  * `SASL/PLAINTEXT`: SASL authentication without encryption
+  * `SASL/SSL`: SASL authentication with SSL encryption
+
+* **Authentication** (when using SASL):
+  * **Security Mechanism**: Choose the SASL mechanism:
+    * `PLAIN`: Simple username/password authentication
+    * `SCRAM-SHA-256`: SCRAM authentication with SHA-256
+    * `SCRAM-SHA-512`: SCRAM authentication with SHA-512
+  * **Username**: SASL authentication username
+  * **Password**: SASL authentication password
+
+### Topic Settings
+* **Topic**: The Kafka topic where events will be published. If the topic doesn't exist, it will be created automatically with default settings.
+
+### Advanced Settings
+* **Additional Configurations**: Add custom Kafka producer configurations in key=value format. Each configuration should be on a new line. For example:
+  ```
+  buffer.memory=33554432
+  batch.size=16384
+  linger.ms=20
+  ```
 
-The basic settings to connect to the broker. 
-The Kafka broker URL indicates the URL of the broker (e.g., localhost), the port indicates the port of the broker
- (e.g., 9092)
+***
 
+## Features
+* **Message Handling**:
+  * Automatic JSON serialization of events
+  * Configurable message size limits
+  * Batch processing support
+  * Automatic topic creation
 
-### Kafka Topic
+* **Security**:
+  * SSL/TLS encryption support
+  * SASL authentication with multiple mechanisms
+  * Configurable security protocols
 
-The topic where events should be sent to.
+***
 
+## Use Cases
+* **Data Distribution**: Publish processed events to Kafka for other systems to consume
+* **Event Streaming**: Stream events to Kafka for real-time processing
+* **Data Integration**: Integrate StreamPipes with Kafka-based data pipelines
 
-### Additional configurations
+***
 
-Can be used to provide additional Kafka producer configurations. Input must be in form of key-value pairs, e.g.
-buffer.memory=33554432
+## Important Notes
+* The sink uses the Kafka Producer API to publish messages
+* Events are automatically serialized to JSON format
+* Topics are created automatically if they don't exist
+* For production use, it's recommended to configure appropriate security settings
+* The sink supports all standard Kafka producer configurations through the additional settings
diff --git a/streampipes-extensions/streampipes-connectors-mqtt/src/main/resources/org.apache.streampipes.connect.iiot.protocol.stream.mqtt/documentation.md b/streampipes-extensions/streampipes-connectors-mqtt/src/main/resources/org.apache.streampipes.connect.iiot.protocol.stream.mqtt/documentation.md
index 3a9e819477..ec5f30804a 100644
--- a/streampipes-extensions/streampipes-connectors-mqtt/src/main/resources/org.apache.streampipes.connect.iiot.protocol.stream.mqtt/documentation.md
+++ b/streampipes-extensions/streampipes-connectors-mqtt/src/main/resources/org.apache.streampipes.connect.iiot.protocol.stream.mqtt/documentation.md
@@ -16,7 +16,7 @@
   ~
   -->
 
-## MQTT
+## MQTT Protocol
 
 <p align="center"> 
     <img src="icon.png" width="150px;" class="pe-image-documentation"/>
@@ -25,23 +25,64 @@
 ***
 
 ## Description
+The MQTT protocol adapter enables StreamPipes to consume messages from an MQTT broker. It provides:
+* Real-time message consumption from MQTT topics
+* Support for various authentication methods
+* Configurable message handling
+* Automatic reconnection handling
+* Support for MQTT 3.1 and 3.1.1 protocols
 
-Consumes messages from a broker using the MQTT protocol
+***
+
+## Configuration
+
+### Broker Settings
+* **Broker URL**: The URL of the MQTT broker (e.g., tcp://test-server.com:1883). The protocol (tcp://) and port are required.
+
+### Topic Settings
+* **Topic**: The MQTT topic to subscribe to (e.g., test/topic)
 
+### Authentication Settings
+* **Access Mode**: Choose between:
+  * **Unauthenticated**: No authentication required
+  * **Username/Password**: Basic authentication with username and password
+    * **Username**: The username for authentication
+    * **Password**: The password for authentication
 
 ***
 
-## Configuration
+## Features
+* **Message Handling**:
+  * Real-time message consumption
+  * Support for MQTT QoS levels
+  * Automatic reconnection on connection loss
+  * Configurable keep-alive settings
+
+* **Security**:
+  * Basic authentication support
+  * TCP protocol support
+  * SSL/TLS support (coming soon)
 
-Describe the configuration parameters here
+* **Protocol Support**:
+  * MQTT 3.1
+  * MQTT 3.1.1
 
-### Broker Url
+***
 
-Example: tcp://test-server.com:1883 (Protocol required. Port required)"
+## Use Cases
+* **IoT Data Collection**: Connect to IoT devices publishing data via MQTT
+* **Sensor Networks**: Subscribe to sensor data streams
+* **Real-time Monitoring**: Monitor real-time data from MQTT-enabled systems
+* **Device Integration**: Integrate with MQTT-based device ecosystems
 
-### Access Mode
+***
 
-Unauthenticated or Authenticated (Username/Password)
+## Important Notes
+* The adapter uses the MQTT protocol for message consumption
+* Messages are received in real-time as they are published to the subscribed topic
+* The adapter automatically handles reconnection if the connection to the broker is lost
+* For production use, it's recommended to use authentication when available
+* The adapter supports both MQTT 3.1 and 3.1.1 protocols
 
 ## Output
 
diff --git a/streampipes-extensions/streampipes-connectors-mqtt/src/main/resources/org.apache.streampipes.sinks.brokers.jvm.mqtt/documentation.md b/streampipes-extensions/streampipes-connectors-mqtt/src/main/resources/org.apache.streampipes.sinks.brokers.jvm.mqtt/documentation.md
index cadccdb4d5..557343eb01 100644
--- a/streampipes-extensions/streampipes-connectors-mqtt/src/main/resources/org.apache.streampipes.sinks.brokers.jvm.mqtt/documentation.md
+++ b/streampipes-extensions/streampipes-connectors-mqtt/src/main/resources/org.apache.streampipes.sinks.brokers.jvm.mqtt/documentation.md
@@ -25,31 +25,86 @@
 ***
 
 ## Description
-
-Publishes events to MQTT.
+The MQTT Publisher sink enables StreamPipes to publish events to MQTT topics. It provides:
+* Real-time event publishing to MQTT topics
+* Support for various authentication methods
+* Configurable message handling
+* Last Will and Testament support
+* MQTT 3.1 and 3.1.1 protocol support
 
 ***
 
-## Required input
+## Configuration
 
-This sink does not have any requirements and works with any incoming event type.
+### Broker Settings
+* **Host**: The hostname or IP address of the MQTT broker
+* **Port**: The port number of the MQTT broker (default: 1883)
+
+### Topic Settings
+* **Topic**: The MQTT topic where events will be published
+
+### Authentication Settings
+* **Authentication**: Choose between:
+  * **Unauthenticated**: No authentication required
+  * **Basic Auth**: Username/password authentication
+    * **Username**: The username for authentication
+    * **Password**: The password for authentication
+
+### Message Settings
+* **QoS Level**: Quality of Service level for message delivery (default: at-least-once)
+* **Clean Session**: Whether to start with a clean session (default: Yes)
+* **Retain Messages**: Whether to retain messages at the broker (default: No)
+* **Keep Alive**: Time in seconds between keep-alive messages (default: 30s)
+
+### Last Will and Testament (Optional)
+* **Last Will Mode**: Choose between:
+  * **No Last Will**: No last will message
+  * **Last Will**: Configure a last will message
+    * **Last Will Topic**: The topic for the last will message
+    * **Last Will Message**: The message to publish
+    * **Last Will QoS**: QoS level for the last will message
+    * **Retain Will Message**: Whether to retain the last will message
+
+### Advanced Settings
+* **MQTT Version**: Whether the broker is MQTT v3.1.1 compliant (default: Yes)
+* **Reconnect Period**: Time in seconds between reconnect attempts (default: 30s)
 
 ***
 
-## Configuration
+## Features
+* **Message Handling**:
+  * Configurable QoS levels
+  * Message retention options
+  * Clean session support
+  * Last Will and Testament
 
-### MQTT Broker Settings
+* **Security**:
+  * Basic authentication support
+  * TCP protocol support
+  * SSL/TLS support (coming soon)
 
-The basic settings to connect to the broker. 
-The MQTT broker URL indicates the URL of the broker (e.g., localhost), the port indicates the port of the broker
-(e.g., 1883)
+* **Protocol Support**:
+  * MQTT 3.1
+  * MQTT 3.1.1
 
+***
 
-### MQTT Topic
+## Use Cases
+* **IoT Data Publishing**: Publish processed data to IoT devices
+* **Real-time Updates**: Send real-time updates to MQTT subscribers
+* **Device Control**: Send control commands to MQTT-enabled devices
+* **System Integration**: Integrate with MQTT-based systems
 
-The topic where events should be sent to.
+***
 
+## Important Notes
+* The sink uses the MQTT protocol for message publishing
+* Events are published in real-time as they are received
+* The sink automatically handles reconnection if the connection to the broker is lost
+* For production use, it's recommended to use authentication when available
+* The sink supports both MQTT 3.1 and 3.1.1 protocols
+* Last Will and Testament can be used to notify other clients of unexpected disconnections
 
-## Output
+## Required input
 
-(not applicable for data sinks)
\ No newline at end of file
+This sink does not have any requirements and works with any incoming event type.
diff --git a/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.jseval/documentation.md b/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.jseval/documentation.md
index de9687234a..a304b76baf 100644
--- a/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.jseval/documentation.md
+++ b/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.jseval/documentation.md
@@ -25,18 +25,28 @@
 ***
 
 ## Description
-A pipeline element that allows writing user defined JavaScript function to enrich events.
+The JavaScript Eval processor allows you to write custom JavaScript functions to transform and enrich events. It:
+* Executes user-defined JavaScript code
+* Provides full access to input event data
+* Supports complex data transformations
+* Enables dynamic field creation and modification
 
 ***
 
-## Required input
-This processor does not have any specific input requirements.
+## Required Input
+The processor works with any input event stream. All fields from the input event are available as properties in the JavaScript function.
 
 ***
 
 ## Configuration
-User can specify their custom enrichment logic within the `process` method. Please note that the `process` function 
-must be in the following format and it must return a map of data which is compatible with the output schema.
+
+### JavaScript Function
+You need to provide a JavaScript function that processes the input event and returns a new event object. The function must:
+* Be named `process`
+* Accept a single parameter containing the input event
+* Return a map/object with the output fields
+
+Example function structure:
 ```javascript
     function process(event) {
         // do processing here.
@@ -45,5 +55,83 @@ must be in the following format and it must return a map of data which is compat
     }
 ```
 
+The defined output schema must match the event that is returned by the JavaScript function.
+
 ## Output
-A new event with the user defined output schema.
\ No newline at end of file
+The processor forwards a new event containing the fields returned by your JavaScript function.
+
+### Example
+
+#### Input Event
+```json
+{
+  "temperature": 25.5,
+  "humidity": 60,
+  "timestamp": 1586380105115
+}
+```
+
+#### Configuration
+```javascript
+function process(event) {
+    // Convert temperature from Celsius to Fahrenheit
+    const tempF = (event.temperature * 9/5) + 32;
+    
+    // Calculate heat index
+    const heatIndex = calculateHeatIndex(tempF, event.humidity);
+    
+    // Return new event with transformed data
+    return {
+        temperature_celsius: event.temperature,
+        temperature_fahrenheit: tempF,
+        humidity: event.humidity,
+        heat_index: heatIndex,
+        timestamp: event.timestamp
+    };
+}
+
+function calculateHeatIndex(temp, humidity) {
+    // Simplified heat index calculation
+    return temp + (humidity * 0.1);
+}
+```
+
+#### Output Event
+```json
+{
+  "temperature_celsius": 25.5,
+  "temperature_fahrenheit": 77.9,
+  "humidity": 60,
+  "heat_index": 83.9,
+  "timestamp": 1586380105115
+}
+```
+
+## Use Cases
+
+1. **Data Transformation**
+   * Unit conversions
+   * Data normalization
+   * Complex calculations
+   * Field restructuring
+
+2. **Data Enrichment**
+   * Adding derived fields
+   * Computing statistics
+   * Combining multiple fields
+   * Creating calculated metrics
+
+3. **Custom Logic**
+   * Business rules implementation
+   * Conditional transformations
+   * Data validation
+   * Custom algorithms
+
+## Notes
+
+* The JavaScript function runs in a GraalVM JavaScript environment
+* All input fields are accessible as properties of the event object
+* The function must return a valid JavaScript object
+* Error handling should be implemented in the JavaScript code
+* Complex JavaScript operations are supported
+* The function is executed for each incoming event, but state can be kept
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.processor.expression/documentation.md b/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.processor.expression/documentation.md
index 3545bb1c06..ecc435e1ee 100644
--- a/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.processor.expression/documentation.md
+++ b/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.processor.expression/documentation.md
@@ -25,31 +25,90 @@
 ***
 
 ## Description
-A pipeline element that evaluates Math expressions using the Apache Commons JEXL library.
+The Math Expression Evaluator processor allows you to perform mathematical calculations on numerical fields using the Apache Commons JEXL library. It:
+* Evaluates mathematical expressions
+* Supports complex calculations
+* Provides access to Java Math functions
+* Creates new fields with calculation results
 
 ***
 
-## Required input
-This processor works with any input stream that contains numerical values.
+## Required Input
+The processor requires an input event stream containing at least one numerical field to perform calculations on.
 
 ***
 
 ## Configuration
-A math expression can be defined using the JEXL syntax (see https://commons.apache.org/proper/commons-jexl/index.html).
 
-Example:
+See more about JEXL syntax at https://commons.apache.org/proper/commons-jexl/index.html.
 
-```
-flow_rate*2
-```
+### Additional Fields
+For each calculation, you need to specify:
+* **Field Name**: The name of the new field that will store the calculation result
+* **Expression**: The mathematical expression to evaluate using JEXL syntax
 
-It is also possible to use methods from `java.lang.Math`:
+### Expression Syntax
+The processor supports:
+* Basic arithmetic operations (+, -, *, /)
+* Mathematical functions from `java.lang.Math`
+* References to input field values
+* Complex expressions with multiple operations
+
+## Output
+The processor forwards the input event with additional fields containing the calculation results.
 
+### Example
+
+#### Input Event
+```json
+{
+  "temperature": 10.1,
+  "flowrate": 2
+}
 ```
-Math.pow(flow_rate^2)
+
+#### Configuration
+* Field Name: `result1`
+* Expression: `temperature+12`
+
+* Field Name: `result2`
+* Expression: `temperature*flowrate`
+
+#### Output Event
+```json
+{
+  "temperature": 10.1,
+  "flowrate": 2,
+  "result1": 22.1,
+  "result2": 20.2
+}
 ```
 
-All fields from th einput stream are available as variables.
+## Use Cases
 
-## Output
-For each expression, an additional field is created in the output stream. Field names are user-defined.
+1. **Data Transformation**
+   * Convert units
+   * Calculate derived metrics
+   * Normalize values
+   * Scale measurements
+
+2. **Statistical Analysis**
+   * Calculate averages
+   * Compute standard deviations
+   * Perform trend analysis
+   * Generate statistical metrics
+
+3. **Business Logic**
+   * Calculate costs
+   * Compute performance metrics
+   * Evaluate business rules
+   * Generate derived values
+
+## Notes
+
+* All input fields are available as variables in expressions
+* The `Math` class is available for advanced calculations
+* Results are stored as double-precision floating-point numbers
+* Expressions are evaluated for each incoming event
+* Invalid expressions will be logged as errors
+* The processor preserves all input fields
diff --git a/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.processor.math.mathop/documentation.md b/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.processor.math.mathop/documentation.md
index 94c104f768..d07f8039bf 100644
--- a/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.processor.math.mathop/documentation.md
+++ b/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.processor.math.mathop/documentation.md
@@ -16,7 +16,7 @@
   ~
   -->
 
-## Math
+## Math Operation
 
 <p align="center"> 
     <img src="icon.png" width="150px;" class="pe-image-documentation"/>
@@ -25,26 +25,89 @@
 ***
 
 ## Description
-
-Performs calculations on event properties (+, -, *, /, %).
+The Math Operation processor performs arithmetic calculations between two numerical fields in an event. It:
+* Supports basic arithmetic operations (+, -, *, /, %)
+* Works with any numerical field type
+* Preserves original event data
+* Adds calculation results as new fields
 
 ***
 
-## Required input
-The math processor works with any event that has at least one field containing a numerical value.
+## Required Input
+The processor requires an input event stream containing at least two numerical fields to perform calculations on.
 
 ***
 
 ## Configuration
 
-### Left operand
-The field from the input event that should be used as the left operand.
+### Left Operand
+Select the field from the input event that should be used as the left operand in the calculation.
 
-### Right operand
-The field from the input event that should be used as the right operand.
+### Right Operand
+Select the field from the input event that should be used as the right operand in the calculation.
 
 ### Operation
-The math operation that should be performed.
+Choose one of the following arithmetic operations:
+* Addition (+)
+* Subtraction (-)
+* Multiplication (*)
+* Division (/)
+* Modulo (%)
 
 ## Output
-The processor appends the calculation result to each input event.
\ No newline at end of file
+The processor forwards the input event with an additional field named `calculationResult` containing the result of the arithmetic operation.
+
+### Example
+
+#### Input Event
+```json
+{
+  "temperature": 25.5,
+  "humidity": 60,
+  "timestamp": 1586380105115
+}
+```
+
+#### Configuration
+* Left Operand: `temperature`
+* Right Operand: `humidity`
+* Operation: `*`
+
+#### Output Event
+```json
+{
+  "temperature": 25.5,
+  "humidity": 60,
+  "timestamp": 1586380105115,
+  "calculationResult": 1530.0
+}
+```
+
+## Use Cases
+
+1. **Data Transformation**
+   * Calculate derived metrics
+   * Convert units
+   * Scale measurements
+   * Normalize values
+
+2. **Business Logic**
+   * Compute costs
+   * Calculate performance metrics
+   * Evaluate business rules
+   * Generate derived values
+
+3. **Sensor Data Processing**
+   * Combine sensor readings
+   * Calculate averages
+   * Normalize measurements
+   * Scale sensor values
+
+## Notes
+
+* Both operands must be numerical values
+* Division by zero will result in an error
+* Results are stored as double-precision floating-point numbers
+* The original event structure is preserved
+* The calculation is performed for each incoming event
+* The result field is always named `calculationResult`
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.processor.math.staticmathop/documentation.md b/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.processor.math.staticmathop/documentation.md
index 4e699fe7d5..563e091ba0 100644
--- a/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.processor.math.staticmathop/documentation.md
+++ b/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.processor.math.staticmathop/documentation.md
@@ -16,7 +16,7 @@
   ~
   -->
 
-## Static Math
+## Static Math Operation
 
 <p align="center"> 
     <img src="icon.png" width="150px;" class="pe-image-documentation"/>
@@ -25,26 +25,87 @@
 ***
 
 ## Description
-
-Performs calculation on an event property with a static value (+, -, *, /, %).
+The Static Math Operation processor performs arithmetic calculations between a numerical field and a static value. It:
+* Supports basic arithmetic operations (+, -, *, /, %)
+* Works with any numerical field type
+* Uses a configurable static value as one operand
+* Updates the input field with the calculation result
+* Preserves other event fields
 
 ***
 
-## Required input
-The math processor works with any event that has at least one field containing a numerical value.
+## Required Input
+The processor requires an input event stream containing at least one numerical field to perform calculations on.
 
 ***
 
 ## Configuration
 
-### Left operand
-The field from the input event that should be used as the left operand.
+### Left Operand
+Select the field from the input event that should be used as the left operand in the calculation.
 
-### Right operand value
-Specify the value of the right operand.
+### Right Operand Value
+Specify the static numerical value that should be used as the right operand in the calculation.
 
 ### Operation
-The math operation that should be performed.
+Choose one of the following arithmetic operations:
+* Addition (+)
+* Subtraction (-)
+* Multiplication (*)
+* Division (/)
+* Modulo (%)
 
 ## Output
-The processor appends the calculation result to each input event.
\ No newline at end of file
+The processor updates the selected input field with the result of the arithmetic operation.
+
+### Example
+
+#### Input Event
+```json
+{
+  "temperature": 25.5,
+  "timestamp": 1586380105115
+}
+```
+
+#### Configuration
+* Left Operand: `temperature`
+* Right Operand Value: `2.0`
+* Operation: `*`
+
+#### Output Event
+```json
+{
+  "temperature": 51.0,
+  "timestamp": 1586380105115
+}
+```
+
+## Use Cases
+
+1. **Unit Conversion**
+   * Converting between measurement units
+   * Scaling values
+   * Normalizing data
+   * Applying conversion factors
+
+2. **Data Transformation**
+   * Applying constant offsets
+   * Scaling measurements
+   * Adjusting values
+   * Normalizing ranges
+
+3. **Signal Processing**
+   * Amplifying signals
+   * Attenuating values
+   * Applying gains
+   * Signal conditioning
+
+## Notes
+
+* The processor updates the input field directly
+* All calculations are performed using double-precision floating-point arithmetic
+* Division by zero will result in an error
+* The modulo operation works with floating-point numbers
+* The original field name is preserved
+* Other event fields remain unchanged
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.processor.trigonometry/documentation.md b/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.processor.trigonometry/documentation.md
index 0454239b91..d04386843c 100644
--- a/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.processor.trigonometry/documentation.md
+++ b/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.processor.trigonometry/documentation.md
@@ -16,7 +16,7 @@
   ~
   -->
 
-## Trigonometry
+## Trigonometry Functions
 
 <p align="center"> 
     <img src="icon.png" width="150px;" class="pe-image-documentation"/>
@@ -25,26 +25,80 @@
 ***
 
 ## Description
-
-Performs Trigonometric functions (sin, cos, tan) on event properties.
+The Trigonometry Functions processor performs trigonometric calculations on numerical values. It:
+* Supports basic trigonometric functions (sin, cos, tan)
+* Works with any numerical field type
+* Preserves original event data
+* Adds calculation results as new fields
 
 ***
 
-## Required input
-The trigonometry processor works with any event that has at least one field containing a numerical value.
+## Required Input
+The processor requires an input event stream containing at least one numerical field to perform trigonometric calculations on.
 
 ***
 
 ## Configuration
 
-Describe the configuration parameters here
-
 ### Alpha
-The field that should be used for calculating the trigonometric function.
-
+Select the field from the input event that should be used as the angle (in radians) for the trigonometric calculation.
 
 ### Operation
-The trigonometric function that should be calculated.
+Choose one of the following trigonometric functions:
+* **sin**: Calculates the sine of the angle
+* **cos**: Calculates the cosine of the angle
+* **tan**: Calculates the tangent of the angle
 
 ## Output
-The processor appends the calculation result to each input event.
\ No newline at end of file
+The processor forwards the input event with an additional field named `trigonometryResult` containing the result of the trigonometric calculation.
+
+### Example
+
+#### Input Event
+```json
+{
+  "angle": 1.57,
+  "timestamp": 1586380105115
+}
+```
+
+#### Configuration
+* Alpha: `angle`
+* Operation: `sin`
+
+#### Output Event
+```json
+{
+  "angle": 1.57,
+  "timestamp": 1586380105115,
+  "trigonometryResult": 0.9999996829318346
+}
+```
+
+## Use Cases
+
+1. **Signal Processing**
+   * Waveform analysis
+   * Signal filtering
+   * Phase calculations
+   * Frequency analysis
+
+2. **Geometric Calculations**
+   * Angle conversions
+   * Distance calculations
+   * Position tracking
+   * Navigation systems
+
+3. **Scientific Computing**
+   * Physics simulations
+   * Engineering calculations
+   * Mathematical modeling
+   * Data analysis
+
+## Notes
+
+* Input angles must be in radians
+* Results are stored as double-precision floating-point numbers
+* The original event structure is preserved
+* The calculation is performed for each incoming event
+* The result field is always named `trigonometryResult`
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.sizemeasure/documentation.md b/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.sizemeasure/documentation.md
index c42a0f2d17..a709a1d61a 100644
--- a/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.sizemeasure/documentation.md
+++ b/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.sizemeasure/documentation.md
@@ -25,19 +25,80 @@
 ***
 
 ## Description
-
-Measures the size of an incoming event and appends this number to the event by serializing it.
+The Size Measure processor calculates and appends the size of incoming events. It:
+* Measures event size through serialization
+* Supports multiple size units (Bytes, Kilobytes, Megabytes)
+* Preserves original event data
+* Adds size information as a new field
 
 ***
 
-## Required input
-The size measure processor does not have any specific input requirements.
+## Required Input
+The processor works with any input event stream, as it measures the size of the entire event structure.
 
 ***
 
 ## Configuration
 
-You can specify if the size should be in Bytes, Kilobytes (1024 Bytes) or in Megabytes (1024 Kilobytes).
+### Size Unit
+Select the unit in which the event size should be measured:
+* **Bytes**: Raw size in bytes
+* **Kilobytes**: Size divided by 1024 (1 KB = 1024 bytes)
+* **Megabytes**: Size divided by 1048576 (1 MB = 1024 KB)
 
 ## 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
+The processor forwards the input event with an additional field named `eventSize` containing the size of the event in the selected unit.
+
+### Example
+
+#### Input Event
+```json
+{
+  "temperature": 25.5,
+  "humidity": 60,
+  "timestamp": 1586380105115
+}
+```
+
+#### Configuration
+* Size Unit: `Kilobytes`
+
+#### Output Event
+```json
+{
+  "temperature": 25.5,
+  "humidity": 60,
+  "timestamp": 1586380105115,
+  "eventSize": 0.09375
+}
+```
+
+## Use Cases
+
+1. **Performance Monitoring**
+   * Track event sizes over time
+   * Monitor data volume
+   * Identify large events
+   * Optimize data transfer
+
+2. **Resource Planning**
+   * Estimate storage requirements
+   * Plan network capacity
+   * Optimize buffer sizes
+   * Scale infrastructure
+
+3. **Debugging**
+   * Identify oversized events
+   * Track data growth
+   * Monitor serialization overhead
+   * Troubleshoot performance issues
+
+## Notes
+
+* Size measurement includes all event fields and metadata
+* The size is calculated through Java serialization
+* Results are stored as double-precision floating-point numbers
+* The original event structure is preserved
+* The size is measured for each incoming event
+* The result field is always named `eventSize`
+* Size measurement adds some processing overhead
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.valuechange/documentation.md b/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.valuechange/documentation.md
index 6a74d9d13f..b2be1bf007 100644
--- a/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.valuechange/documentation.md
+++ b/streampipes-extensions/streampipes-processors-enricher-jvm/src/main/resources/org.apache.streampipes.processors.enricher.jvm.valuechange/documentation.md
@@ -26,21 +26,90 @@
 ***
 
 ## Description
-
-The processing element should be able to detect when a numeric property change from one configured value to another.
+The Value Change processor detects specific transitions in numerical values. It:
+* Monitors a selected numerical field
+* Detects when the value changes from one specified value to another
+* Adds a boolean flag indicating the detected change
+* Preserves all original event data
+* Works with any numerical field type
 
 ***
 
-## Required input
-The required input is a number. 
+## Required Input
+The processor requires an input event stream containing at least one numerical field to monitor for specific value transitions.
 
 ***
 
 ## Configuration
-Value of last event (example: 0)
 
-Value of current event (example: 5)
+### Property to Monitor
+Select the numerical field from the input event that should be monitored for value changes.
+
+### From Value
+Specify the initial value that should trigger the change detection. The processor will look for transitions from this value.
 
+### To Value
+Specify the target value that should complete the change detection. The processor will look for transitions to this value.
 
 ## Output
-A boolean value is returned when the input changes.
\ No newline at end of file
+The processor forwards the input event with an additional boolean field named `isChanged` that indicates whether the specified value transition was detected.
+
+### Example
+
+#### Input Event
+```json
+{
+  "temperature": 25.5,
+  "timestamp": 1586380105115
+}
+```
+
+```json
+{
+  "temperature": 26.0,
+  "timestamp": 1586380105116,
+}
+```
+
+#### Configuration
+* Property to Monitor: `temperature`
+* From Value: `25.5`
+* To Value: `26.0`
+
+#### Output Event
+```json
+{
+  "temperature": 26.0,
+  "timestamp": 1586380105116,
+  "isChanged": true
+}
+```
+
+## Use Cases
+
+1. **State Transition Detection**
+   * Monitoring system states
+   * Detecting mode changes
+   * Tracking status transitions
+   * Identifying phase changes
+
+2. **Threshold Monitoring**
+   * Detecting crossing of specific thresholds
+   * Monitoring value ranges
+   * Tracking boundary conditions
+   * Identifying critical transitions
+
+3. **Process Control**
+   * Monitoring control system states
+   * Detecting process transitions
+   * Tracking operational modes
+   * Identifying state changes
+
+## Notes
+
+* The processor only detects exact matches for the specified values
+* The change detection is sequential (must go from "From Value" to "To Value")
+* The original event structure is preserved
+* The boolean flag is added to every event
+* The processor maintains state between events
+* Values are compared using exact equality
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.compose/documentation.md b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.compose/documentation.md
index 62dfc52302..8a8b0c0441 100644
--- a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.compose/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.compose/documentation.md
@@ -25,20 +25,93 @@
 ***
 
 ## Description
+The Compose processor merges two event streams by combining their properties. It supports:
+* Real-time event stream merging
+* Last-event state tracking
+* Custom output field selection
+* Dynamic event composition
+* Stateful event processing
 
-Merges two event streams. Any time, a new input event arrives, it is merged with the last input event from the other 
-event stream and forwarded.
+This processor is essential for:
+* Combining data from multiple sources
+* Creating unified event views
+* Merging related event streams
+* Building composite event structures
 
 ***
 
-## Required input
-The Compose processor does not have any specific input requirements.
+## Required Input
+The processor requires two input streams:
+* First stream: Any event stream with at least one property
+* Second stream: Any event stream with at least one property
 
 ***
 
 ## Configuration
 
-(no further configuration required)
+### Output Selection
+During pipeline modeling, you can select which fields from each stream should be included in the output event. The processor will:
+* Keep the last event from each stream in memory
+* Merge selected fields when new events arrive
+* Forward the combined event with selected fields
 
 ## Output
-The compose processor has a configurable output that can be selected by the user at pipeline modeling time.
\ No newline at end of file
+The processor creates a new event containing the selected fields from both input streams. The output is generated whenever:
+* A new event arrives from either stream
+* The last event from the other stream is available
+
+### Example
+
+#### Input Event Stream 1
+```json
+{
+  "deviceId": "sensor01",
+  "temperature": 25.5,
+  "timestamp": 1586380104915
+}
+```
+
+#### Input Event Stream 2
+```json
+{
+  "location": "room1",
+  "humidity": 45.2,
+  "timestamp": 1586380104915
+}
+```
+
+#### Configuration
+* Output Fields: deviceId, temperature, location, humidity
+
+#### Output Event
+```json
+{
+  "deviceId": "sensor01",
+  "temperature": 25.5,
+  "location": "room1",
+  "humidity": 45.2
+}
+```
+
+## Use Cases
+
+1. **Data Integration**
+   * Combine sensor readings
+   * Merge related metrics
+   * Create unified views
+   * Join event streams
+
+2. **Event Enrichment**
+   * Add context to events
+   * Combine related data
+   * Create composite events
+   * Build rich event structures
+
+## Notes
+
+* Events are merged in real-time
+* Last event state is maintained
+* Output fields are configurable
+* Original event structure is preserved
+* Events are forwarded on any new input
+* State is cleared on pipeline stop
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.enrich/documentation.md b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.enrich/documentation.md
index d7c6c14cd9..913d6e25a8 100644
--- a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.enrich/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.enrich/documentation.md
@@ -16,7 +16,7 @@
   ~
   -->
 
-## Enrich By Merging 
+## Merge By Enrich
 
 <p align="center"> 
     <img src="icon.png" width="150px;" class="pe-image-documentation"/>
@@ -25,17 +25,94 @@
 ***
 
 ## Description
-Merges two data streams by enriching one of the streams with the properties of the other stream. The output frequency is the same as the frequency of the stream which is enriched.
+The Merge By Enrich processor combines two event streams by enriching one stream with properties from the other. It supports:
+* Real-time event stream enrichment
+* Last-event state tracking
+* Custom output field selection
+* Dynamic event composition
+* Stateful event processing
+
+This processor is essential for:
+* Enriching events with additional context
+* Combining related data streams
+* Creating unified event views
+* Building composite event structures
+
 ***
 
-## Required input
-None
+## Required Input
+The processor requires two input streams:
+* First stream: Any event stream with at least one property
+* Second stream: Any event stream with at least one property
+
 ***
 
 ## Configuration
 
-* Select the stream which should be enriched with the properties of the other stream.
-  * The last event of the stream is hold in state and each event of the other stream is enriched by the properties the user selected
+### Stream Selection
+During pipeline modeling, you can:
+* Select which stream should be enriched (Stream 1 or Stream 2)
+* Choose which fields from each stream should be included in the output
+* The processor will maintain the event frequency of the selected stream
 
 ## Output
-The compose processor has a configurable output that can be selected by the user at pipeline modeling time.
\ No newline at end of file
+The processor creates a new event containing the selected fields from both input streams. The output is generated whenever:
+* A new event arrives from the selected stream
+* The last event from the other stream is available
+
+### Example
+
+#### Input Event Stream 1
+```json
+{
+  "deviceId": "sensor01",
+  "temperature": 25.5,
+  "timestamp": 1586380104915
+}
+```
+
+#### Input Event Stream 2
+```json
+{
+  "location": "room1",
+  "humidity": 45.2,
+  "timestamp": 1586380104915
+}
+```
+
+#### Configuration
+* Selected Stream: Stream 1
+* Output Fields: deviceId, temperature, location, humidity
+
+#### Output Event
+```json
+{
+  "deviceId": "sensor01",
+  "temperature": 25.5,
+  "location": "room1",
+  "humidity": 45.2
+}
+```
+
+## Use Cases
+
+1. **Event Enrichment**
+   * Add context to sensor readings
+   * Combine related metrics
+   * Create unified views
+   * Join event streams
+
+2. **Data Integration**
+   * Merge sensor data
+   * Combine related events
+   * Create composite events
+   * Build rich event structures
+
+## Notes
+
+* Events are enriched in real-time
+* Last event state is maintained
+* Output fields are configurable
+* Original event structure is preserved
+* Events are forwarded at the frequency of the selected stream
+* State is cleared on pipeline stop
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.limit/documentation.md b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.limit/documentation.md
index 92fce7481e..a78ed9a772 100644
--- a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.limit/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.limit/documentation.md
@@ -25,40 +25,115 @@
 ***
 
 ## Description
-This limits the number of events emitted based on a specified criterion such as time, and number of events.
+The Rate Limit processor controls the frequency of events in a data stream by applying various windowing strategies. It supports:
+* Time-based rate limiting
+* Event count-based rate limiting
+* Cron-based rate limiting
+* Group-based rate limiting
+* Multiple event selection strategies
+
+This processor is essential for:
+* Controlling data flow rates
+* Reducing system load
+* Implementing sampling strategies
+* Managing resource utilization
 
 ***
 
-## Required input
-The processor works with any input event.
+## Required Input
+The processor works with any input event stream.
 
 ***
 
 ## Configuration
 
-### Enable Grouping
-Enabling this will use grouping with rate-limiting (note: disabling this will ignore `Grouping Field` property).
+### Grouping Settings
+* **Enable Grouping**: When enabled, rate limiting is applied separately to each group
+* **Grouping Field**: Field to use as the grouping key (only used when grouping is enabled)
 
-### Grouping Field
-Runtime field to be used as the grouping key. If grouping is disabled, this setting will be ignored.
+### Window Configuration
+Select one of the following window types:
 
-### Window Type
-This specifies the type of window to be used (time / length / cron).
+1. **Time Window**
+   * Window size in milliseconds
+   * Events are grouped by time intervals
+   * Example: 1000ms window emits events every second
 
-### Length Window Size
-Length window size in event count (note: only works with length window type).
+2. **Length Window**
+   * Window size in event count
+   * Events are grouped by count
+   * Example: Window size of 10 emits every 10 events
 
-### Time Window Size
-Time window size in milliseconds (note: only works with time window type).
+3. **Cron Window**
+   * Cron expression for scheduling
+   * Events are grouped by schedule
+   * Example: `0 * * ? * *` emits every minute
 
-### Cron Window Expression
-Cron expression [Link](https://www.freeformatter.com/cron-expression-generator-quartz.html) to trigger and emit events (i.e `0 * * ? * *` for every minute) (note: only works with cron window type).
-
-### Output Event Selection
-This specifies the event(s) that are selected to be emitted.
-- First: emit first event of the window.
-- Last: emit last event of the window.
-- All: emit all events of the window.
+### Event Selection
+Choose how events are selected from each window:
+* **First**: Emit the first event in the window
+* **Last**: Emit the last event in the window
+* **All**: Emit all events in the window
 
 ## Output
-The processor outputs events which satisfies rate-limiting conditions.
+The processor outputs events based on the configured window and selection strategy. The output maintains the original event structure.
+
+### Example
+
+#### Input Events
+```json
+{
+  "deviceId": "sensor01",
+  "temperature": 25.5,
+  "timestamp": 1586380104915
+}
+{
+  "deviceId": "sensor01",
+  "temperature": 26.0,
+  "timestamp": 1586380105015
+}
+{
+  "deviceId": "sensor01",
+  "temperature": 25.8,
+  "timestamp": 1586380105115
+}
+```
+
+#### Configuration
+* Window Type: Time Window
+* Window Size: 1000ms
+* Event Selection: Last
+* Grouping: Disabled
+
+#### Output Events
+```json
+{
+  "deviceId": "sensor01",
+  "temperature": 25.8,
+  "timestamp": 1586380105115
+}
+```
+
+## Use Cases
+
+1. **Data Sampling**
+   * Reduce high-frequency sensor data
+   * Sample large event streams
+   * Control data flow rates
+   * Implement periodic reporting
+
+2. **Resource Management**
+   * Prevent system overload
+   * Manage downstream processing
+   * Control storage rates
+   * Optimize network usage
+
+## Notes
+
+* Windows are processed independently for each group
+* Event selection is applied after window completion
+* State is maintained per group
+* Windows are cleared after processing
+* Cron expressions follow Quartz scheduler format
+* Time windows use system time
+* Length windows count all events
diff --git a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.merge/documentation.md b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.merge/documentation.md
index b8eed628b7..47eed82b79 100644
--- a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.merge/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.merge/documentation.md
@@ -16,7 +16,7 @@
   ~
   -->
 
-## Merge By Timestamp 
+## Merge By Time
 
 <p align="center"> 
     <img src="icon.png" width="150px;" class="pe-image-documentation"/>
@@ -25,27 +25,92 @@
 ***
 
 ## Description
-
-Merges two event streams by their timestamp.
-Two events of the different streams are merged when they occure to the same time
-
-The following figure shows how the events of the two data streams will be mergrged:
+The Merge By Time processor combines events from two data streams based on their timestamps. It merges events when their timestamps fall within a specified time interval of each other. This processor is essential for:
+* Synchronizing data from multiple sources
+* Correlating events across different streams
+* Creating unified views of time-aligned data
+* Implementing time-based event matching
 
 <p align="center"> 
     <img width="300px;" src="merge_description.png" class="pe-image-documentation"/>
 </p>
-
 ***
 
-## Required input
-Each of the data streams needs a timestamp.
+## Required Input
+Each input stream must contain a timestamp field that can be used for matching events.
 
 ***
 
 ## Configuration
 
-* For each stream a the timestamp property on which the merger is performed has to be selected
-* The Time Interval describes the maximum value between two events to decide whether they are a match. To be a valid match the following function must be true: | timestamp_stream_1 - timestamp_stream_2 | < interval
+### Timestamp Selection
+* **Stream 1 Timestamp**: Select the timestamp field from the first input stream
+* **Stream 2 Timestamp**: Select the timestamp field from the second input stream
+
+### Time Interval
+* Specifies the maximum time difference (in milliseconds) between events for them to be considered a match
+* Events are merged when: |timestamp_stream_1 - timestamp_stream_2| < interval
+* Example: With interval = 1000ms, events within 1 second of each other will be merged
 
 ## Output
-The Compose processor has a configurable output that can be selected by the user at pipeline modeling time.
\ No newline at end of file
+The processor creates a new event containing all fields from both input events when their timestamps match within the specified interval.
+
+### Example
+
+#### Input Events
+Stream 1:
+```json
+{
+  "deviceId": "sensor01",
+  "temperature": 25.5,
+  "timestamp": 1586380104915
+}
+```
+
+Stream 2:
+```json
+{
+  "location": "room1",
+  "humidity": 45,
+  "timestamp": 1586380105015
+}
+```
+
+#### Configuration
+* Stream 1 Timestamp: timestamp
+* Stream 2 Timestamp: timestamp
+* Time Interval: 1000ms
+
+#### Output Event
+```json
+{
+  "deviceId": "sensor01",
+  "temperature": 25.5,
+  "location": "room1",
+  "humidity": 45,
+  "timestamp": 1586380105015
+}
+```
+
+## Use Cases
+
+1. **Sensor Data Correlation**
+   * Combine temperature and humidity readings
+   * Merge location and environmental data
+   * Synchronize multiple sensor streams
+   * Create unified sensor views
+
+2. **Event Synchronization**
+   * Align events from different sources
+   * Match related events across streams
+   * Create time-aligned data views
+   * Implement temporal joins
+
+## Notes
+
+* Events are matched based on absolute time difference
+* Buffer management prevents memory overflow
+* Events outside the time interval are not merged
+* Original event structure is preserved in output
+* Timestamps must be in milliseconds
+* Both streams must have valid timestamp fields
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.movingaverage/documentation.md b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.movingaverage/documentation.md
index e9debe873a..fd868bf5ad 100644
--- a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.movingaverage/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.movingaverage/documentation.md
@@ -17,24 +17,107 @@
   -->
 
 ## Moving Average
-***
 
+<p align="center"> 
+    <img src="icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
 
-## Description
+***
 
-Smooths the data stream by the mean/median of the last n values.
+## Description
+The Moving Average processor smooths numerical data streams by calculating either the mean or median of the last n values. This processor is essential for:
+* Reducing noise in sensor data
+* Smoothing out fluctuations
+* Identifying trends
+* Improving data quality
 
 ***
 
-## Required input
-A numerical field is required.
+## Required Input
+A numerical field is required in the input stream.
+
 ***
 
 ## Configuration
+
+### Numerical Field
+* Select the numerical field to be smoothed
+* The field must contain numeric values
+
 ### N Value
-Specifies the number of previous data points which are used to smooth the data.
+* Specifies the window size (number of previous values to consider)
+* Larger values create smoother output but increase latency
+* Smaller values are more responsive but may show more noise
+
 ### Method
-Specifies the method which is used to smooth the data. Choose between mean and median.
+Choose between two smoothing methods:
+* **Mean**: Calculates the arithmetic average of the last n values
+* **Median**: Uses the middle value of the last n values (better for handling outliers)
 
 ## Output
-Appends a field with the smoothed data.
\ No newline at end of file
+The processor appends a new field named "filterResult" containing the smoothed value.
+
+### Example
+
+#### Input Events
+```json
+{
+  "temperature": 25.5,
+  "timestamp": 1586380104915
+}
+{
+  "temperature": 26.0,
+  "timestamp": 1586380105015
+}
+{
+  "temperature": 25.8,
+  "timestamp": 1586380105115
+}
+```
+
+#### Configuration
+* Numerical Field: temperature
+* N Value: 3
+* Method: Mean
+
+#### Output Events
+```json
+{
+  "temperature": 25.5,
+  "timestamp": 1586380104915,
+  "filterResult": 25.5
+}
+{
+  "temperature": 26.0,
+  "timestamp": 1586380105015,
+  "filterResult": 25.75
+}
+{
+  "temperature": 25.8,
+  "timestamp": 1586380105115,
+  "filterResult": 25.77
+}
+```
+
+## Use Cases
+
+1. **Sensor Data Processing**
+   * Smooth temperature readings
+   * Filter noise from measurements
+   * Stabilize sensor outputs
+   * Improve data quality
+
+2. **Trend Analysis**
+   * Identify long-term patterns
+   * Reduce short-term fluctuations
+   * Highlight significant changes
+   * Monitor system behavior
+
+## Notes
+
+* The processor maintains a sliding window of the last n values
+* Mean method is more sensitive to outliers
+* Median method is more robust against outliers
+* Window size affects smoothing intensity
+* Original values are preserved in the output
+* First n-1 events will have partial windows
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.numericalfilter/documentation.md b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.numericalfilter/documentation.md
index 8fc23fedb5..68c8a9aad8 100644
--- a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.numericalfilter/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.numericalfilter/documentation.md
@@ -25,26 +25,127 @@
 ***
 
 ## Description
-The Numerical Filter processor filters numerical values based on a given threshold.
+The Numerical Filter processor filters events based on numerical comparisons with a specified threshold. It supports various comparison operations and is ideal for:
+* Threshold-based event filtering
+* Range-based data selection
+* Outlier detection
+* Value-based event routing
 
 ***
 
-## Required input
-The processor works with any input event that has one field containing a numerical value.
+## Required Input
+A data stream containing at least one numerical field to filter on.
 
 ***
 
 ## Configuration
 
 ### Field
-Specifies the field name where the filter operation should be applied on.
-
+* Select the numerical field to apply the filter operation on
+* The field must contain numeric values
 
 ### Operation
-Specifies the filter operation that should be applied on the field.
+Choose from the following comparison operators:
+* **<** (Less than)
+* **<=** (Less than or equal)
+* **>** (Greater than)
+* **>=** (Greater than or equal)
+* **==** (Equal)
+* **!=** (Not equal)
 
-### Threshold value
-Specifies the threshold value.
+### Threshold Value
+* Specify the numerical threshold to compare against
+* The value must be a valid number
 
 ## Output
-The processor outputs the input event if it satisfies the filter expression.
\ No newline at end of file
+The processor forwards the input event only if the numerical comparison evaluates to true.
+
+### Example
+
+#### Input Events
+```json
+{
+  "temperature": 25.5,
+  "timestamp": 1586380104915
+}
+{
+  "temperature": 26.0,
+  "timestamp": 1586380105015
+}
+{
+  "temperature": 25.8,
+  "timestamp": 1586380105115
+}
+```
+
+#### Example 1: Greater Than Filter
+Configuration:
+* Field: temperature
+* Operation: >
+* Threshold Value: 25.8
+
+Output Events:
+```json
+{
+  "temperature": 26.0,
+  "timestamp": 1586380105015
+}
+```
+
+#### Example 2: Range Filter
+Configuration:
+* Field: temperature
+* Operation: >=
+* Threshold Value: 25.5
+
+Output Events:
+```json
+{
+  "temperature": 25.5,
+  "timestamp": 1586380104915
+}
+{
+  "temperature": 26.0,
+  "timestamp": 1586380105015
+}
+{
+  "temperature": 25.8,
+  "timestamp": 1586380105115
+}
+```
+
+#### Example 3: Exact Match Filter
+Configuration:
+* Field: temperature
+* Operation: ==
+* Threshold Value: 25.8
+
+Output Events:
+```json
+{
+  "temperature": 25.8,
+  "timestamp": 1586380105115
+}
+```
+
+## Use Cases
+
+1. **Threshold Monitoring**
+   * Alert on values exceeding limits
+   * Filter out normal readings
+   * Monitor critical thresholds
+   * Track value ranges
+
+2. **Data Quality**
+   * Remove outliers
+   * Filter invalid measurements
+   * Ensure value ranges
+   * Validate sensor data
+
+## Notes
+
+* The processor performs exact numerical comparisons
+* For equality checks, a small epsilon (0.000001) is used to handle floating-point precision
+* Events that don't match the filter condition are dropped
+* The original event structure is preserved in the output
+* All numerical types (integer, float, double) are supported
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.numericaltextfilter/documentation.md b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.numericaltextfilter/documentation.md
index 88147ade76..00361e369b 100644
--- a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.numericaltextfilter/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.numericaltextfilter/documentation.md
@@ -22,40 +22,99 @@
     <img src="icon.png" width="150px;" class="pe-image-documentation"/>
 </p>
 
-
 ***
 
 ## Description
-The Numerical Text Filter processor filters numerical values based on a given threshold and text values 
-based on a given string. It only forwards events in case both criteria are satisfied.
+The Numerical Text Filter processor combines numerical and text-based filtering in a single processor. It forwards events only when both the numerical and text conditions are satisfied. This processor is ideal for:
+* Complex event filtering
+* Multi-criteria event selection
+* Data validation
+* Event routing based on multiple conditions
 
 ***
 
-## Required input
-The processor works with any input event that has one field containing a numerical value and one field 
-containing a text.
+## Required Input
+The processor requires an input event stream containing:
+* At least one numerical field for numerical comparison
+* At least one text field for string matching
 
 ***
 
 ## Configuration
 
-### Number Field
-Specifies the field name where the filter operation should be applied on.
-
-### Number Operation
-Specifies the filter operation that should be applied on the field.
-
-### Number Threshold
-Specifies the threshold value.
-
-### Text Field
-The field containing the text that should be filtered.
-
-### Text Operation
-The operation used by the filter processor (equals or matches).
-
-### Text Keyword
-Specifies the keyword to filter the text field.
+### Numerical Filter
+* **Field**: Select the numerical field to apply the filter operation on
+* **Operation**: Choose from the following comparison operators:
+  * **<** (Less than)
+  * **<=** (Less than or equal)
+  * **>** (Greater than)
+  * **>=** (Greater than or equal)
+  * **==** (Equal)
+  * **!=** (Not equal)
+* **Threshold**: Specify the numerical value to compare against
+
+### Text Filter
+* **Field**: Select the text field to apply the filter operation on
+* **Operation**: Choose from:
+  * **MATCHES**: Exact string match
+  * **CONTAINS**: Substring match
+* **Keyword**: Specify the text to match against
 
 ## Output
-The processor outputs the input event if it satisfies the filter expression.
+The processor forwards the input event only if both the numerical and text conditions evaluate to true.
+
+### Example
+
+#### Input Event
+```json
+{
+  "temperature": 25.5,
+  "status": "active",
+  "timestamp": 1586380104915
+}
+```
+
+#### Configuration
+Numerical Filter:
+* Field: temperature
+* Operation: >
+* Threshold: 20.0
+
+Text Filter:
+* Field: status
+* Operation: MATCHES
+* Keyword: active
+
+#### Output Event
+```json
+{
+  "temperature": 25.5,
+  "status": "active",
+  "timestamp": 1586380104915
+}
+```
+
+## Use Cases
+
+1. **Sensor Data Filtering**
+   * Filter sensor readings based on value ranges and status
+   * Monitor specific conditions in sensor data
+   * Validate sensor readings against expected patterns
+
+2. **Event Validation**
+   * Ensure events meet both numerical and categorical criteria
+   * Validate business rules with multiple conditions
+   * Filter events based on complex criteria
+
+3. **Data Quality Control**
+   * Filter out invalid or unexpected data combinations
+   * Ensure data meets quality thresholds
+   * Validate data against business rules
+
+## Notes
+
+* Both numerical and text conditions must be satisfied for an event to be forwarded
+* Numerical comparisons use floating-point precision (0.000001 tolerance for equality)
+* Text matching is case-sensitive
+* The processor preserves the original event structure
+* All fields from the input event are included in the output
diff --git a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.processor.booleanfilter/documentation.md b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.processor.booleanfilter/documentation.md
index 11d3d1545d..53194a37ab 100644
--- a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.processor.booleanfilter/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.processor.booleanfilter/documentation.md
@@ -25,22 +25,90 @@
 ***
 
 ## Description
-The Boolean Filter processor filters based on a boolean value field
+The Boolean Filter processor filters events based on a boolean field value. It supports:
+* Exact boolean value matching
+* Event forwarding on match
+* Simple true/false filtering
+* State-based event filtering
+
+This processor is essential for:
+* Filtering events by boolean state
+* Implementing conditional event routing
+* State-based event processing
+* Boolean condition filtering
 
 ***
 
 ## Required Input
-The processor works with any input event that has one field containing a boolean value
+The processor requires a data stream containing at least one boolean field to filter on.
 
 ***
 
 ## Configuration
 
 ### Field
-Specifies the field name where the filter operation should be applied on.
+Select the boolean field to filter on. The processor will check this field's value against the selected filter value.
 
 ### Field Value
-Events with the selected field value are forwarded
+Choose whether to keep events where the field value is:
+* True - Only events with true values are forwarded
+* False - Only events with false values are forwarded
 
 ## Output
-The processor outputs the input event if the event value is equals the selected field value
\ No newline at end of file
+The processor creates a new event containing all original fields from the input event, but only when the selected boolean field matches the configured value.
+
+### Example
+
+#### Input Event Stream
+```json
+{
+  "deviceId": "sensor01",
+  "location": "l1",
+  "isActive": true,
+  "timestamp": 1586380104915
+}
+```
+```json
+{
+  "deviceId": "sensor01",
+  "location": "l1",
+  "isActive": false,
+  "timestamp": 1586380105015
+}
+```
+
+#### Configuration
+* Field: isActive
+* Field Value: True
+
+#### Output Event
+```json
+{
+  "deviceId": "sensor01",
+  "location": "l1",
+  "isActive": true,
+  "timestamp": 1586380104915
+}
+```
+
+## Use Cases
+
+1. **State Filtering**
+   * Filter active/inactive states
+   * Process only enabled devices
+   * Handle operational states
+   * Filter by status flags
+
+2. **Conditional Processing**
+   * Route events by condition
+   * Filter by boolean flags
+   * Process based on state
+   * Handle boolean triggers
+
+## Notes
+
+* Only exact boolean matches are supported
+* Events are forwarded unchanged
+* No transformation of values
+* Simple true/false filtering
+* Original event structure preserved
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.project/documentation.md b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.project/documentation.md
index 4438a64351..fe3c49897a 100644
--- a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.project/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.project/documentation.md
@@ -25,18 +25,78 @@
 ***
 
 ## Description
-Outputs a selectable subset of an input event type.
+The Projection processor allows you to select a subset of fields from input events, creating a new event with only the specified fields. This processor is essential for:
+* Reducing data volume
+* Focusing on relevant fields
+* Data privacy
+* Stream optimization
 
 ***
 
-## Required input
-The project processor works with any input event stream.
+## Required Input
+The processor works with any input event stream containing one or more fields.
 
 ***
 
 ## Configuration
-
-(no further configuration required)
+At pipeline development time, you can select which fields to include in the output event.
 
 ## Output
-The output depends on the fields selected at pipeline development time.
\ No newline at end of file
+The processor creates a new event containing only the selected fields from the input event.
+
+### Example
+
+#### Input Event
+```json
+{
+  "temperature": 25.5,
+  "humidity": 60,
+  "pressure": 1013,
+  "timestamp": 1586380104915,
+  "device_id": "sensor_001",
+  "location": "room_101"
+}
+```
+
+#### Configuration
+Selected fields:
+* temperature
+* humidity
+* timestamp
+
+#### Output Event
+```json
+{
+  "temperature": 25.5,
+  "humidity": 60,
+  "timestamp": 1586380104915
+}
+```
+
+## Use Cases
+
+1. **Data Volume Reduction**
+   * Remove unnecessary fields
+   * Reduce network bandwidth
+   * Optimize storage
+   * Improve processing speed
+
+2. **Data Privacy**
+   * Remove sensitive fields
+   * Anonymize data
+   * Control data exposure
+   * Comply with regulations
+
+3. **Stream Optimization**
+   * Focus on relevant data
+   * Reduce downstream processing
+   * Improve pipeline efficiency
+   * Optimize resource usage
+
+## Notes
+
+* The processor preserves the original values of selected fields
+* Fields not selected are completely removed from the output
+* The order of fields in the output may differ from the input
+* All field types are supported
+* The processor can handle any number of fields
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.schema/documentation.md b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.schema/documentation.md
index cbc1c474f4..df35ff9f6a 100644
--- a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.schema/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.schema/documentation.md
@@ -16,25 +16,101 @@
   ~
   -->
 
-## Merge By Schema 
+## Merge By Schema
 
+<p align="center"> 
+    <img src="icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
 
+***
 
 ## Description
-
-Merges two events by their schema.
-It checks two whether the schemas of two events are equal or not.
-If the schemas are not equal we can throw SpRuntimeException otherwise we can collect them. 
+The Merge By Schema processor combines events from two input streams that share the same event schema. It ensures data consistency by only merging events that have identical structures. This processor is essential for:
+* Schema validation
+* Data consistency enforcement
+* Stream synchronization
+* Event structure verification
 
 ***
 
-## Required input
-Two events are needed.
+## Required Input
+The processor requires two input streams that must have:
+* Identical event schemas
+* Matching property names and types
+* Compatible data structures
+
 ***
 
 ## Configuration
-
-For each stream schema info should be present
+No additional configuration is required. The processor automatically:
+* Validates schema compatibility
+* Ensures structural consistency
+* Maintains data integrity
 
 ## Output
-Events with same schemas.
\ No newline at end of file
+The processor forwards events from both input streams, ensuring they maintain their original structure and values.
+
+### Example
+
+#### Input Stream 1 Event
+```json
+{
+  "temperature": 25.5,
+  "humidity": 60,
+  "timestamp": 1586380104915
+}
+```
+
+#### Input Stream 2 Event
+```json
+{
+  "temperature": 26.0,
+  "humidity": 65,
+  "timestamp": 1586380105015
+}
+```
+
+#### Output Events
+Both events are forwarded as they share the same schema:
+```json
+{
+  "temperature": 25.5,
+  "humidity": 60,
+  "timestamp": 1586380104915
+}
+```
+```json
+{
+  "temperature": 26.0,
+  "humidity": 65,
+  "timestamp": 1586380105015
+}
+```
+
+## Use Cases
+
+1. **Data Validation**
+   * Ensure consistent data structures
+   * Validate event schemas
+   * Maintain data quality
+   * Enforce schema compliance
+
+2. **Stream Synchronization**
+   * Combine compatible data streams
+   * Merge homogeneous data sources
+   * Maintain data consistency
+   * Ensure structural alignment
+
+3. **Quality Assurance**
+   * Verify data structure integrity
+   * Validate event formats
+   * Ensure schema compatibility
+   * Maintain data standards
+
+## Notes
+
+* The processor throws an exception if schemas do not match
+* All events maintain their original structure
+* No data transformation is performed
+* Events are forwarded as-is from both streams
+* Schema validation is performed at runtime
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.textfilter/documentation.md b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.textfilter/documentation.md
index 36ca78ab51..2840b0f943 100644
--- a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.textfilter/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.textfilter/documentation.md
@@ -25,23 +25,82 @@
 ***
 
 ## Description
-The Text Filter processor filters text values based on a given string.
+The Text Filter processor filters events based on text field content. It allows you to:
+* Match exact text strings
+* Check for text containment
+* Filter events based on text criteria
+* Route events based on text content
 
 ***
 
-## Required input
-The processor works with any input event that has one field containing a text.
+## Required Input
+The processor requires an input event stream containing at least one text field to filter on.
 
 ***
 
 ## Configuration
 
 ### Text Field
-The field containing the text that should be filtered.
-
+Select the field containing the text that should be filtered.
 
 ### Operation
-The operation used by the filter processor (equals or matches)
+Choose from two filtering operations:
+* **MATCHES**: Exact string matching (case-sensitive)
+* **CONTAINS**: Substring matching (case-sensitive)
+
+### Keyword
+Specify the text string to match against.
 
 ## Output
-The processor outputs the input event if it satisfies the filter expression.
\ No newline at end of file
+The processor forwards the input event only if the text field satisfies the filter condition.
+
+### Example
+
+#### Input Event
+```json
+{
+  "message": "Temperature warning: 25.5°C",
+  "timestamp": 1586380104915
+}
+```
+
+#### Configuration
+* Text Field: `message`
+* Operation: `CONTAINS`
+* Keyword: `warning`
+
+#### Output Event
+```json
+{
+  "message": "Temperature warning: 25.5°C",
+  "timestamp": 1586380104915
+}
+```
+
+## Use Cases
+
+1. **Event Routing**
+   * Route events based on text content
+   * Filter log messages
+   * Process specific error messages
+   * Handle different event types
+
+2. **Content Filtering**
+   * Filter text-based alerts
+   * Process specific keywords
+   * Extract relevant messages
+   * Filter notifications
+
+3. **Data Validation**
+   * Validate text content
+   * Ensure required text patterns
+   * Filter invalid messages
+   * Enforce text standards
+
+## Notes
+
+* Text matching is case-sensitive
+* The processor preserves the original event structure
+* No text transformation is performed
+* Events that don't match the filter are dropped
+* The filter operates on the exact text field value
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.threshold/documentation.md b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.threshold/documentation.md
index dff0d71875..73e26fed82 100644
--- a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.threshold/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.threshold/documentation.md
@@ -25,26 +25,89 @@
 ***
 
 ## Description
-The Threshold Detector processor appends a boolean whether the condition is fulfilled or not
+The Threshold Detector processor monitors numerical values and detects when they cross specified thresholds. It:
+* Compares numerical values against a threshold
+* Appends a boolean flag indicating threshold status
+* Supports various comparison operations
+* Preserves all input data while adding threshold information
 
 ***
 
-## Required input
-The processor works with any input event that has one field containing a numerical value.
+## Required Input
+The processor requires an input event stream containing at least one numerical field to monitor.
 
 ***
 
 ## Configuration
 
 ### Field
-Specifies the field name where the filter operation should be applied on.
-
+Select the numerical field to monitor for threshold crossing.
 
 ### Operation
-Specifies the filter operation that should be applied on the field.
+Choose from six comparison operations:
+* **<** (Less than)
+* **<=** (Less than or equal)
+* **>** (Greater than)
+* **>=** (Greater than or equal)
+* **==** (Equal)
+* **!=** (Not equal)
 
-### Threshold value
-Specifies the threshold value.
+### Threshold Value
+Specify the numerical threshold value to compare against.
 
 ## Output
-Appends a boolean with the value whether the condition is fulfilled or not.
+The processor forwards the input event with an additional boolean field `thresholdDetected` indicating whether the threshold condition was met.
+
+### Example
+
+#### Input Event
+```json
+{
+  "temperature": 25.5,
+  "humidity": 60,
+  "timestamp": 1586380104915
+}
+```
+
+#### Configuration
+* Field: `temperature`
+* Operation: `>`
+* Threshold Value: `25.0`
+
+#### Output Event
+```json
+{
+  "temperature": 25.5,
+  "humidity": 60,
+  "timestamp": 1586380104915,
+  "thresholdDetected": true
+}
+```
+
+## Use Cases
+
+1. **Monitoring & Alerting**
+   * Monitor sensor readings
+   * Detect threshold crossings
+   * Trigger alerts
+   * Track value ranges
+
+2. **Quality Control**
+   * Monitor process parameters
+   * Detect out-of-range values
+   * Ensure quality standards
+   * Track compliance
+
+3. **Data Analysis**
+   * Analyze value distributions
+   * Track threshold events
+   * Monitor trends
+   * Identify patterns
+
+## Notes
+
+* The processor preserves all input fields
+* The `thresholdDetected` field is always appended
+* Floating-point comparisons use a small epsilon (0.000001) for equality
+* All events are forwarded, regardless of threshold status
+* The threshold check is performed on the exact numerical value
diff --git a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.throughputmon/documentation.md b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.throughputmon/documentation.md
index bf71467e84..e22f00f0a7 100644
--- a/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.throughputmon/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-jvm/src/main/resources/org.apache.streampipes.processors.filters.jvm.throughputmon/documentation.md
@@ -16,7 +16,7 @@
   ~
   -->
 
-## Throughput monitoring
+## Throughput Monitor
 
 <p align="center"> 
     <img src="icon.png" width="150px;" class="pe-image-documentation"/>
@@ -25,26 +25,94 @@
 ***
 
 ## Description
-The Throughput Monitoring processor computes throughput statistics.
+The Throughput Monitor processor calculates and reports event processing throughput statistics. It:
+* Measures event processing rates
+* Tracks batch processing windows
+* Calculates events per second
+* Provides detailed timing information
 
 ***
 
 ## Required Input
-The processor works with any input event.
+The processor works with any input event stream, as it focuses on measuring event flow rather than event content.
 
 ***
 
 ## Configuration
 
 ### Batch Window Size
-Specifies the number of events that should be used for calculating throughput statistics.
-
+Specifies the number of events that should be collected before calculating throughput statistics. This determines:
+* How frequently throughput is calculated
+* The granularity of the measurements
+* The trade-off between accuracy and reporting frequency
 
 ## Output
 The processor outputs a new event containing:
-* The current timestamp (timestamp)
-* The start time of the batch window (starttime)
-* The end time of the batch window (endtime)
-* The duration between both windows (duration)
-* The number of events collected in the window (should be equal to batch size)
-* The throughput in events per second
+* `timestamp`: Current system timestamp
+* `starttime`: Start time of the batch window
+* `endtime`: End time of the batch window
+* `duration`: Duration of the batch window in milliseconds
+* `eventcount`: Number of events processed in the window
+* `throughput`: Events per second (calculated as eventcount / (duration/1000))
+
+### Example
+
+#### Input Events (3 events with batch size 3)
+```json
+{
+  "sensorValue": 42,
+  "timestamp": 1586380104915
+}
+{
+  "sensorValue": 43,
+  "timestamp": 1586380105015
+}
+{
+  "sensorValue": 44,
+  "timestamp": 1586380105115
+}
+```
+
+#### Configuration
+* Batch Window Size: `3`
+
+#### Output Event
+```json
+{
+  "timestamp": 1586380105115,
+  "starttime": 1586380104915,
+  "endtime": 1586380105115,
+  "duration": 200,
+  "eventcount": 3,
+  "throughput": 15.0
+}
+```
+
+## Use Cases
+
+1. **Performance Monitoring**
+   * Monitor pipeline throughput
+   * Track processing rates
+   * Identify bottlenecks
+   * Measure system performance
+
+2. **Load Testing**
+   * Measure processing capacity
+   * Test system limits
+   * Validate performance
+   * Benchmark improvements
+
+3. **Resource Planning**
+   * Estimate resource needs
+   * Plan capacity
+   * Optimize configurations
+   * Scale infrastructure
+
+## Notes
+
+* The processor uses a sliding window approach
+* Throughput is calculated as events per second
+* All timing is in milliseconds
+* The batch window size affects measurement granularity
+* Events are counted as they arrive
+* The processor resets after each batch window
diff --git a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.count/documentation.md b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.count/documentation.md
index bebc063b6c..b1064383e4 100644
--- a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.count/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.count/documentation.md
@@ -18,43 +18,94 @@
 
 ## Count Aggregation
 
-Performs count aggregation with Siddhi CEP engine.
+<p align="center"> 
+    <img src="icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
 
 ***
 
 ## Description
-
-Performs an aggregation based on a given field and outputs the number of occurrences.
-Example: Count the number of vehicle positions per vehicleId.
-The Count aggregation requires a time window, used to perform the count aggregation and a field used to aggregate
-values.
+The Count Aggregation processor performs counting operations on event streams. It:
+* Counts occurrences of values within a configurable time window
+* Groups events by a specified field
+* Provides real-time counting statistics
+* Supports flexible time window configurations
+* Preserves timestamp information
 
 ***
 
-## Required input
-
-Does not have any specific input requirements.
+## Required Input
+The processor requires an input event stream containing:
+* A timestamp field for window-based processing
+* At least one field to count occurrences of
 
 ***
 
 ## Configuration
 
-### FieldToCount    
-Specifies the field containing the values that should be counted.
+### Field to Count
+Select the field from the input event that should be used for counting occurrences. This field's values will be grouped and counted.
 
-### TimeWindowSize  
-Specifies the size of the time window and consequently the number of values that are aggregated each time. 
+### Time Window Size
+Specify the duration of the time window for aggregation. This determines how many events will be considered in each counting operation.
 
 ### Time Window Scale
-Specifies the scale/unit of the time window. There are three different time scales to choose from: seconds, minutes or hours.
+Choose the time unit for the window size:
+* Hours
+* Minutes
+* Seconds
 
 ## Output
-The output event is composed of two fields. The field "value" specifies the value to count.
-The second field "count" returns the number of occurrences.
-Example:
+The processor outputs events containing:
+* `timestamp`: The timestamp of the window
+* `value`: The value being counted
+* `count`: The number of occurrences within the time window
+
+### Example
+
+#### Input Event
+```json
+{
+  "vehicleId": "V123",
+  "timestamp": 1586380105115
+}
 ```
+
+#### Configuration
+* Field to Count: `vehicleId`
+* Time Window Size: `5`
+* Time Window Scale: `Minutes`
+
+#### Output Event
+```json
 {
-  'value': 'vehicleId', 
-  'count': 12
+  "timestamp": 1586380105115,
+  "value": "V123",
+  "count": 12
 }
 ```
+
+## Use Cases
+
+1. **Traffic Analysis**
+   * Count vehicle passes at intersections
+   * Monitor traffic flow rates
+   * Track vehicle frequency
+
+2. **Event Monitoring**
+   * Count error occurrences
+   * Track system events
+   * Monitor user actions
+
+3. **Resource Usage**
+   * Count API calls
+   * Monitor service requests
+   * Track resource utilization
+
+## Notes
+
+* The processor uses sliding time windows
+* Counts are reset at the end of each window
+* Timestamps are preserved from the input events
+* The processor groups events by the selected field
+* Results are emitted at the end of each time window
diff --git a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.frequency/documentation.md b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.frequency/documentation.md
index 5f2637c7b9..b912ce031a 100644
--- a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.frequency/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.frequency/documentation.md
@@ -16,34 +16,84 @@
   ~
   -->
 
-## Frequency Calculation
+## Frequency Monitor
 
-Frequency calculation with Siddhi CEP engine.
+<p align="center"> 
+    <img src="icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
 
 ***
 
 ## Description
-
-Calculates the frequency of the event stream.
+The Frequency Monitor processor detects when events stop arriving within a specified time window. It:
+* Monitors event arrival frequency
+* Detects when events stop arriving
+* Supports configurable time windows
+* Works with any input event stream
+* Preserves original event data
 
 ***
 
-## Required input
-
-Does not have any specific input requirements.
+## Required Input
+The processor works with any input event stream. No specific input requirements are needed.
 
 ***
 
 ## Configuration
 
-### Time Unit
-
-The time unit of the window. e.g, hrs, min and sec
+### Time Window Length
+Specify the duration of the time window in seconds. If no events arrive within this window, the processor will detect a frequency change.
 
-### Time window length 
-
-The time duration of the window in seconds.
+### Time Unit
+Choose the time unit for the window size:
+* Hours (hrs)
+* Minutes (min)
+* Seconds (sec)
 
 ## Output
-
-Outputs the events according to the frequency specified.
+The processor outputs the original event when no events arrive within the specified time window.
+
+### Example
+
+#### Input Event
+```json
+{
+  "temperature": 25.5,
+  "timestamp": 1586380105115
+}
+```
+
+#### Configuration
+* Time Window Length: `30`
+* Time Unit: `sec`
+
+#### Output Event
+The processor will output the last received event if no new events arrive within 30 seconds.
+
+## Use Cases
+
+1. **System Monitoring**
+   * Detect sensor failures
+   * Monitor data source health
+   * Identify connection issues
+   * Track system availability
+
+2. **Alert Generation**
+   * Trigger alerts on data gaps
+   * Notify on system downtime
+   * Report on service interruptions
+   * Monitor data flow continuity
+
+3. **Quality Assurance**
+   * Ensure data stream continuity
+   * Monitor data collection reliability
+   * Track system performance
+   * Validate data source health
+
+## Notes
+
+* The processor detects the absence of events
+* The time window is configurable in hours, minutes, or seconds
+* Original event data is preserved in the output
+* The processor works with any type of input event
+* Results are emitted when the time window expires without new events
diff --git a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.frequencychange/documentation.md b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.frequencychange/documentation.md
index ebcbede9e3..d4ab8082e3 100644
--- a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.frequencychange/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.frequencychange/documentation.md
@@ -15,38 +15,92 @@
   ~ limitations under the License.
   ~
   -->
-## Frequency Change
 
-Notifies if there is a frequency change in events.
+## Frequency Change Monitor
+
+<p align="center"> 
+    <img src="icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
 
 ***
 
 ## Description
-
-Detects when the frequency of the event stream changes.
+The Frequency Change Monitor processor detects significant changes in event arrival frequency. It:
+* Monitors event arrival patterns
+* Detects percentage-based frequency changes
+* Supports configurable time windows
+* Works with any input event stream
+* Preserves original event data
 
 ***
 
-## Required input
-
-Does not have any specific input requirements.
+## Required Input
+The processor works with any input event stream. No specific input requirements are needed.
 
 ***
 
 ## Configuration
 
-### Time Unit
+### Time Window Length
+Specify the duration of the time window in seconds. The processor will monitor event frequency changes within this window.
 
-The time unit of the window. e.g, hrs, min and sec
+### Time Unit
+Choose the time unit for the window size:
+* Hours (hrs)
+* Minutes (min)
+* Seconds (sec)
 
 ### Percentage of Increase/Decrease
-
-Specifies the increase in percent (e.g., 100 indicates an increase by 100 percent within the specified time window).
-
-### Time window length 
-
-The time duration of the window in seconds.
+Specify the threshold for frequency change detection:
+* Value represents percentage change (e.g., 100 means 100% increase)
+* Range: 0-500%
+* Step size: 1%
 
 ## Output
-
-Outputs event if there is a frequency change according to the provided configuration.
+The processor outputs the original event when a significant frequency change is detected within the specified time window.
+
+### Example
+
+#### Input Event
+```json
+{
+  "temperature": 25.5,
+  "timestamp": 1586380105115
+}
+```
+
+#### Configuration
+* Time Window Length: `30`
+* Time Unit: `sec`
+* Percentage of Increase/Decrease: `100`
+
+#### Output Event
+The processor will output the event if the frequency of events changes by 100% or more within a 30-second window.
+
+## Use Cases
+
+1. **Anomaly Detection**
+   * Identify unusual event patterns
+   * Detect sudden changes in data flow
+   * Monitor system behavior changes
+   * Track event rate anomalies
+
+2. **Performance Monitoring**
+   * Monitor system throughput changes
+   * Track data processing rates
+   * Identify bottlenecks
+   * Measure system responsiveness
+
+3. **Quality Assurance**
+   * Ensure consistent data flow
+   * Monitor data collection reliability
+   * Track system performance
+   * Validate data source health
+
+## Notes
+
+* The processor detects percentage-based changes in event frequency
+* The time window is configurable in hours, minutes, or seconds
+* Original event data is preserved in the output
+* The processor works with any type of input event
+* Results are emitted when the frequency change threshold is exceeded
diff --git a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.increase/documentation.md b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.increase/documentation.md
index 0c77183e40..1ac181c19f 100644
--- a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.increase/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.increase/documentation.md
@@ -16,7 +16,7 @@
   ~
   -->
 
-## Trend
+## Trend Analysis
 
 <p align="center"> 
     <img src="icon.png" width="150px;" class="pe-image-documentation"/>
@@ -25,35 +25,95 @@
 ***
 
 ## Description
-
-Detects the increase of a numerical field over a customizable time window. Example: A temperature value increases by 10 percent within 5 minutes.
+The Trend Analysis processor monitors numerical values and detects significant increases or decreases within a configurable time window. It:
+* Detects percentage-based value changes
+* Supports both increase and decrease detection
+* Uses configurable time windows
+* Preserves original event data
+* Works with any numerical field
 
 ***
 
-## Required input
-
-There should be a number field in the event to observe the trend.
+## Required Input
+The processor requires an input event stream with at least one numerical field to monitor for trends.
 
 ***
 
 ## Configuration
 
 ### Value to Observe
+Select the numerical field that should be monitored for trends.
 
-Specifies the value field that should be monitored.
-
-### Increase/Decrease
-
-Specifies the type of operation the processor should perform.
+### Operation Type
+Choose the type of trend to detect:
+* Increase: Detects when values increase by the specified percentage
+* Decrease: Detects when values decrease by the specified percentage
 
-### Percentage of Increase/Decrease
-
-Specifies the increase in percent (e.g., 100 indicates an increase by 100 percent within the specified time window).
+### Percentage Change
+Specify the percentage threshold for trend detection:
+* For increase: Values must increase by this percentage
+* For decrease: Values must decrease by this percentage
+* Range: 0-500%
+* Step size: 1%
 
 ### Time Window Length (Seconds)
-
-Specifies the size of the time window in seconds.
+Specify the duration in seconds to monitor for the trend.
 
 ## Output
-
-Outputs the events if there is a trend observed according to the configuration defined.
\ No newline at end of file
+The processor outputs the original event when a significant trend is detected within the specified time window.
+
+### Example
+
+#### Input Event
+```json
+{
+  "device_id": "device1",
+  "measurement": "temperature",
+  "value": 25.5,
+  "timestamp": 1586380105115
+}
+```
+
+#### Configuration
+* Value to Observe: `value`
+* Operation Type: `Increase`
+* Percentage Change: `10`
+* Time Window Length: `300`
+
+#### Output Event
+```json
+{
+  "device_id": "device1",
+  "measurement": "temperature",
+  "value": 28.0,
+  "timestamp": 1586380205115
+}
+```
+
+## Use Cases
+
+1. **Anomaly Detection**
+   * Detect sudden temperature changes
+   * Monitor pressure variations
+   * Track resource usage spikes
+   * Identify unusual patterns
+
+2. **Performance Monitoring**
+   * Track system metrics
+   * Monitor resource utilization
+   * Analyze performance trends
+   * Detect degradation
+
+3. **Quality Assurance**
+   * Monitor process parameters
+   * Track product quality metrics
+   * Detect process deviations
+   * Ensure consistent output
+
+## Notes
+
+* The processor detects percentage-based changes
+* The time window is specified in seconds
+* The output includes the original event data
+* The processor works with any numerical field
+* Results are emitted when the trend is detected
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.listcollector/documentation.md b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.listcollector/documentation.md
index d38794c06d..49eb300ed4 100644
--- a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.listcollector/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.listcollector/documentation.md
@@ -18,28 +18,85 @@
 
 ## List Collector
 
+<p align="center"> 
+    <img src="icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
 ***
 
 ## Description
-
-Collects all values from a field within a specified batch window into a list.
+The List Collector processor aggregates values from a specified field into a list within a configurable batch window. It:
+* Collects field values over time
+* Creates a list of all values in the window
+* Preserves original event data
+* Adds a new list field to the output
+* Works with any field type
 
 ***
 
-## Required input
-
-Does not have any specific input requirements.
+## Required Input
+The processor requires an input event stream with at least one field to collect values from.
 
 ***
 
 ## Configuration
 
 ### Field
-
-The field where values should be collected into a list.
+Select the field whose values should be collected into a list. The field can be of any data type.
 
 ### Batch Window Size
+Specify the number of events to include in each batch window. The processor will collect values from this many events before creating a new list.
+
+## Output
+The processor outputs the original event with an additional field containing the collected list of values.
+
+### Example
+
+#### Input Event
+```json
+{
+  "temperature": 25.5,
+  "timestamp": 1586380105115
+}
+```
+
+#### Configuration
+* Field: `temperature`
+* Batch Window Size: `5`
+
+#### Output Event
+```json
+{
+  "temperature": 25.5,
+  "timestamp": 1586380105115,
+  "temperature_list": [22.1, 23.4, 24.2, 25.0, 25.5]
+}
+```
+
+## Use Cases
+
+1. **Data Aggregation**
+   * Collect time series data
+   * Create value histories
+   * Track changes over time
+   * Build data windows
+
+2. **Analysis Preparation**
+   * Prepare data for statistical analysis
+   * Create input for trend detection
+   * Generate data for pattern recognition
+   * Build feature vectors
+
+3. **Monitoring**
+   * Track value distributions
+   * Monitor value ranges
+   * Analyze value patterns
+   * Create value snapshots
 
-The batch window size.
+## Notes
 
-## Output
\ No newline at end of file
+* The processor creates a new list field with the original field name plus "_list"
+* Lists are created after the specified number of events
+* Original event data is preserved
+* The processor works with any field type
+* Lists are cleared after each batch window
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.listfilter/documentation.md b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.listfilter/documentation.md
index 314694d2d7..b5c9167060 100644
--- a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.listfilter/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.listfilter/documentation.md
@@ -16,7 +16,7 @@
   ~
   -->
 
-## Trend
+## List Filter
 
 <p align="center"> 
     <img src="icon.png" width="150px;" class="pe-image-documentation"/>
@@ -25,23 +25,72 @@
 ***
 
 ## Description
-
-Detects the increase of a numerical field over a customizable time window. Example: A temperature value increases by 10 percent within 5 minutes.
+The List Filter processor filters events based on the presence of a specific value in a list field. It:
+* Checks if a value exists in a list
+* Filters events based on list membership
+* Preserves original event data
+* Works with any list field type
+* Supports exact value matching
 
 ***
 
-## Required input
-
+## Required Input
+The processor requires an input event stream with at least one list field to filter on.
 
 ***
 
 ## Configuration
 
-Describe the configuration parameters here
+### List Field
+Select the list field to check for the required value. The field must be a list type.
+
+### Required Value
+Specify the value to look for in the list. The processor will only output events where this value is present in the selected list field.
+
+## Output
+The processor outputs only those events where the specified value is found in the selected list field.
+
+### Example
+
+#### Input Event
+```json
+{
+  "sensor_id": "sensor1",
+  "measurements": [22.1, 23.4, 24.2, 25.0, 25.5]
+}
+```
+
+#### Configuration
+* List Field: `measurements`
+* Required Value: `25.0`
+
+#### Output Event
+The processor will output the event because 25.0 is present in the measurements list.
+
+## Use Cases
+
+1. **Data Filtering**
+   * Filter events by list membership
+   * Select specific value occurrences
+   * Filter based on value presence
+   * Create value-based subsets
 
-### 1st parameter
+2. **Event Selection**
+   * Select events with specific values
+   * Filter based on value existence
+   * Create value-based event streams
+   * Implement value-based routing
 
+3. **Quality Control**
+   * Filter valid measurements
+   * Select events with expected values
+   * Filter based on value criteria
+   * Implement value-based validation
 
-### 2nd parameter
+## Notes
 
-## Output
\ No newline at end of file
+* The processor performs exact value matching
+* Original event data is preserved
+* The processor works with any list field type
+* Events are only output if the value is found
+* List order does not affect filtering
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.sequence/documentation.md b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.sequence/documentation.md
index e76f827906..fc07050227 100644
--- a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.sequence/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.sequence/documentation.md
@@ -16,7 +16,7 @@
   ~
   -->
 
-## Sequence Detection
+## Sequence Monitor
 
 <p align="center"> 
     <img src="icon.png" width="150px;" class="pe-image-documentation"/>
diff --git a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.stop/documentation.md b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.stop/documentation.md
index 1a9ea9d3e7..9c7963d14d 100644
--- a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.stop/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.stop/documentation.md
@@ -18,33 +18,81 @@
 
 ## Stream Stop Detection
 
+<p align="center"> 
+    <img src="icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
 ***
 
 ## Description
-
-Triggers an event when the input data stream stops sending events
+The Stream Stop Detection processor monitors an input stream and triggers an event when no new events arrive for a specified duration. It:
+* Detects stream interruptions
+* Monitors event arrival patterns
+* Triggers alerts on stream stops
+* Provides timestamp of detection
+* Works with any event stream type
 
 ***
 
-## Required input
-
-Does not have any specific input requirements.
+## Required Input
+The processor works with any input event stream and does not require specific fields.
 
 ***
 
 ## Configuration
 
 ### Time Window Length (Seconds)
-
-Specifies the size of the time window in seconds.
+Specify the duration in seconds to wait for events before triggering the stop detection. If no events arrive within this time window, the processor will output a stop detection event.
 
 ## Output
+The processor outputs an event with a timestamp and a message indicating that the stream has stopped.
 
-Outputs a similar event like below.
+### Example
 
+#### Input Event
+```json
+{
+  "sensor_id": "sensor1",
+  "temperature": 25.5,
+  "timestamp": 1586380105115
+}
 ```
+
+#### Configuration
+* Time Window Length: `60` (seconds)
+
+#### Output Event
+```json
 {
-  'timestamp': 1621243855401,
-  'message': 'Event stream has stopped'  
+  "timestamp": 1586380165115,
+  "message": "Event stream has stopped"
 }
-```
\ No newline at end of file
+```
+
+## Use Cases
+
+1. **System Monitoring**
+   * Detect sensor failures
+   * Monitor data source health
+   * Track stream reliability
+   * Identify connection issues
+
+2. **Alert Generation**
+   * Trigger alerts on stream stops
+   * Notify on data gaps
+   * Monitor system health
+   * Detect anomalies
+
+3. **Quality Assurance**
+   * Ensure continuous data flow
+   * Monitor data consistency
+   * Track stream reliability
+   * Validate system performance
+
+## Notes
+
+* The processor triggers when no events arrive for the specified duration
+* The output includes a timestamp of when the stop was detected
+* The processor works with any event stream type
+* The time window is specified in seconds
+* The processor provides a clear message indicating stream stop
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.topk/documentation.md b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.topk/documentation.md
index 141cf14cd4..115e9d58df 100644
--- a/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.topk/documentation.md
+++ b/streampipes-extensions/streampipes-processors-filters-siddhi/src/main/resources/org.apache.streampipes.processors.siddhi.topk/documentation.md
@@ -16,7 +16,7 @@
   ~
   -->
 
-## List Collector
+## Top K Analysis
 
 <p align="center"> 
     <img src="icon.png" width="150px;" class="pe-image-documentation"/>
@@ -25,23 +25,117 @@
 ***
 
 ## Description
-
-Detects the increase of a numerical field over a customizable time window. Example: A temperature value increases by 10 percent within 5 minutes.
+The Top K Analysis processor collects incoming events in a configurable time window and outputs the top or bottom K events based on a specified count value. It:
+* Aggregates events within a time window
+* Ranks events by their count values
+* Supports both ascending and descending order
+* Preserves original event data
+* Works with any event stream type
 
 ***
 
-## Required input
-
+## Required Input
+The processor requires an input event stream with:
+* A field containing values to be counted
+* A field containing count values for ranking
 
 ***
 
 ## Configuration
 
-Describe the configuration parameters here
+### Field
+Select the field whose values should be counted and ranked.
+
+### Count Field
+Select the field containing the count values used for ranking the events.
+
+### Batch Window Size
+Specify the number of events to include in each batch window.
+
+### Time Window Scale
+Choose the time unit for the batch window:
+* Hours
+* Minutes
+* Seconds
+
+### Limit
+Specify the maximum number of events to output (K value).
+
+### Order
+Select the ranking order:
+* Ascending: Outputs the bottom K events
+* Descending: Outputs the top K events
+
+## Output
+The processor outputs a list of the top or bottom K events from each batch window. Each event in the list contains:
+* The value field from the input event
+* The count value used for ranking
+
+### Example
+
+#### Input Event
+```json
+{
+  "device_id": "device1",
+  "measurement": "temperature",
+  "value": 25.5,
+  "occurrences": 15,
+  "timestamp": 1586380105115
+}
+```
+
+#### Configuration
+* Field: `device_id`
+* Count Field: `occurrences`
+* Batch Window Size: `60`
+* Time Window Scale: `Seconds`
+* Limit: `3`
+* Order: `Descending`
+
+#### Output Event
+```json
+{
+  "top": [
+    {
+      "value": "device1",
+      "count": 15
+    },
+    {
+      "value": "device2",
+      "count": 12
+    },
+    {
+      "value": "device3",
+      "count": 10
+    }
+  ]
+}
+```
+
+## Use Cases
+
+1. **Performance Analysis**
+   * Identify top performing sensors
+   * Monitor high-frequency events
+   * Track resource usage patterns
+   * Analyze system bottlenecks
 
-### 1st parameter
+2. **Anomaly Detection**
+   * Find unusual event patterns
+   * Identify outliers
+   * Monitor system behavior
+   * Detect anomalies
 
+3. **Resource Optimization**
+   * Identify high-usage resources
+   * Monitor system load
+   * Track performance metrics
+   * Optimize resource allocation
 
-### 2nd parameter
+## Notes
 
-## Output
\ No newline at end of file
+* The processor uses a sliding time window for analysis
+* Events are ranked based on their count values
+* The output includes the original event data
+* The time window is configurable in hours, minutes, or seconds
+* The processor supports both top K and bottom K analysis
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.counter/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.counter/documentation.md
index bd7b00b9a7..10dd2f5db0 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.counter/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.counter/documentation.md
@@ -26,35 +26,158 @@
 
 ## Description
 
-This processor monitors a boolean value and counts how often the value of the boolean changes.
-A user can configure whether the changes from FALSE to TRUE, TRUE to FALSE, or BOTH changes should be counted.
+The Boolean Counter processor counts state changes in a boolean field. It supports:
+* Rising edge counting (FALSE -> TRUE)
+* Falling edge counting (TRUE -> FALSE)
+* Both edge counting
+* Incremental counting
+* State change detection
+* Event-based counting
+
+This processor is essential for:
+* Counting state transitions
+* Tracking signal changes
+* Monitoring event frequency
+* Measuring cycle counts
+* Analyzing state patterns
+* Building event counters
 
 ***
 
 ## Required input
 
-A boolean value is required in the data stream and can be selected with the field mapping.
+The processor requires a data stream containing at least one boolean field to monitor for state changes.
+
+***
+
+## Configuration
 
 ### Boolean Field
 
-The boolean value to be monitored.
+Select the boolean field to monitor for state changes. This field will be used to detect edges and increment the counter.
 
-***
+### Flank Parameter
 
-## Configuration
+Choose which state changes to count:
 
-A user can configure whether the changes from TRUE to FALSE, FALSE to TRUE, or all changes of the
-boolean value should be counted.
+* **FALSE -> TRUE**: Count rising edges only
+  * Triggers when signal changes from false to true
+  * Use for: Counting activations
+  * Example: Count device startups
 
-### Flank parameter
+* **TRUE -> FALSE**: Count falling edges only
+  * Triggers when signal changes from true to false
+  * Use for: Counting deactivations
+  * Example: Count device shutdowns
 
-Either:
-* TRUE -> FALSE: Increase counter on a true followed by a false
-* FALSE -> TRUE: Increase counter on a false followed by a true
-* BOTH: Increase counter on each change of the boolean value on two consecutive events
+* **BOTH**: Count all state changes
+  * Triggers on any state change
+  * Use for: Counting all transitions
+  * Example: Count all state changes
 
 ## Output
 
-Adds an additional numerical field with the current count value to the event.
-Events are just emitted when the counter changes.
-Runtime Name: countField
\ No newline at end of file
+The processor creates a new event containing:
+* All original fields from the input event
+* A new field named "counter" containing the current count
+
+### Example
+
+#### Input Event Stream
+```json
+[
+  {
+    "deviceId": "machine01",
+    "isRunning": false,
+    "timestamp": 1586380104915
+  },
+  {
+    "deviceId": "machine01",
+    "isRunning": true,
+    "timestamp": 1586380105015
+  },
+  {
+    "deviceId": "machine01",
+    "isRunning": false,
+    "timestamp": 1586380105115
+  }
+]
+```
+
+#### Configuration 1: Rising Edge Counting
+* Boolean Field: isRunning
+* Flank Parameter: FALSE -> TRUE
+
+#### Output Event
+```json
+{
+  "deviceId": "machine01",
+  "isRunning": true,
+  "timestamp": 1586380105015,
+  "counter": 1
+}
+```
+
+#### Configuration 2: Both Edges Counting
+* Boolean Field: isRunning
+* Flank Parameter: BOTH
+
+#### Output Events
+```json
+{
+  "deviceId": "machine01",
+  "isRunning": true,
+  "timestamp": 1586380105015,
+  "counter": 1
+}
+```
+```json
+{
+  "deviceId": "machine01",
+  "isRunning": false,
+  "timestamp": 1586380105115,
+  "counter": 2
+}
+```
+
+## Use Cases
+
+1. **Equipment Monitoring**
+   * Count machine cycles
+   * Track state changes
+   * Monitor activations
+   * Count operations
+   * Track usage patterns
+
+2. **Process Control**
+   * Count process steps
+   * Track state transitions
+   * Monitor phase changes
+   * Count operations
+   * Track cycles
+
+3. **Event Detection**
+   * Count button presses
+   * Track switch changes
+   * Monitor transitions
+   * Count events
+   * Track occurrences
+
+4. **System Analysis**
+   * Count state changes
+   * Track transitions
+   * Monitor patterns
+   * Count events
+   * Track frequencies
+
+## Notes
+
+* Only boolean fields can be counted
+* Counter is incremental
+* Count starts at 0
+* Processing is stateful
+* Counter persists between events
+* Events are only emitted on state changes
+* Counter is reset on pipeline restart
+* Multiple counters require chaining
+* Edge detection is immediate
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.inverter/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.inverter/documentation.md
index 496e981a0e..9316b1bf97 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.inverter/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.inverter/documentation.md
@@ -26,20 +26,104 @@
 
 ## Description
 
-This processor requires a boolean value in the data stream and inverts its value. (e.g. true -> flase)
+The Boolean Inverter processor inverts the value of a boolean field in a data stream. It supports:
+* Single field inversion
+* TRUE to FALSE conversion
+* FALSE to TRUE conversion
+* In-place value modification
+* Simple boolean logic
+* Direct value negation
+
+This processor is essential for:
+* Negating boolean conditions
+* Inverting control signals
+* Complementing state values
+* Reversing logic gates
+* Creating opposite states
+* Implementing NOT operations
 
 ***
 
 ## Required input
 
-### Boolean Field
-
-The boolean value to be inverted.
+The processor requires a data stream containing at least one boolean field to invert.
 
 ***
 
 ## Configuration
-No further configuration required
+
+### Invert Field
+
+Select the boolean field to invert. This field's value will be negated (TRUE becomes FALSE, FALSE becomes TRUE).
 
 ## Output
-The output schema is the same as the input schema. Just the value of the property is changed.
\ No newline at end of file
+
+The processor creates a new event containing:
+* All original fields from the input event
+* The selected field with its value inverted
+
+### Example
+
+#### Input Event
+```json
+{
+  "deviceId": "sensor01",
+  "isActive": true,
+  "timestamp": 1586380104915
+}
+```
+
+#### Configuration
+* Invert Field: isActive
+
+#### Output Event
+```json
+{
+  "deviceId": "sensor01",
+  "isActive": false,
+  "timestamp": 1586380104915
+}
+```
+
+## Use Cases
+
+1. **Control Systems**
+   * Invert control signals
+   * Negate status flags
+   * Reverse logic gates
+   * Complement states
+   * Create opposite conditions
+
+2. **State Management**
+   * Invert state values
+   * Negate status indicators
+   * Reverse boolean flags
+   * Complement conditions
+   * Create inverse states
+
+3. **Logic Operations**
+   * Implement NOT gates
+   * Negate conditions
+   * Reverse boolean logic
+   * Complement expressions
+   * Create opposite states
+
+4. **Signal Processing**
+   * Invert digital signals
+   * Negate binary values
+   * Reverse boolean states
+   * Complement conditions
+   * Create inverse signals
+
+## Notes
+
+* Only boolean fields can be inverted
+* Inversion is in-place
+* Original value is replaced
+* Processing is stateless
+* Multiple inversions require chaining
+* Consider logic implications
+* Inversion is immediate
+* No delay in processing
+* No additional fields created
+* Simple boolean negation
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.logical/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.logical/documentation.md
index 039865443c..5a74bc263e 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.logical/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.logical/documentation.md
@@ -16,21 +16,166 @@
   ~
   -->
 
-## Boolean Operator
+## Boolean Logical Operator
+
+<p align="center">
+    <img src="icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
+***
 
 ## Description
 
-This processor performs the logical boolean operation b/w the vales of set of properties.
-A user can select the type of operation and set of properties.
+The Boolean Logical Operator processor performs logical operations on multiple boolean fields. It supports:
+* Standard logical operations (AND, OR, NOT, XOR, XNOR, NOR)
+* Multiple input fields
+* Single output field
+* Truth table based operations
+* Complex boolean logic
+* State combination
+
+This processor is essential for:
+* Combining multiple conditions
+* Implementing decision logic
+* Creating composite states
+* Building safety interlocks
+* Monitoring complex conditions
+* Implementing control logic
 
 ***
 
 ## Required input
 
-Type of logical boolean operator and set of properties on which operator needs to perform.
+The processor requires a data stream containing at least one boolean field for NOT operations, or at least two boolean fields for all other operations.
 
 ***
 
+## Configuration
+
+### Properties
+
+Select one or more boolean fields to use as operands for the logical operation. The number of fields required depends on the selected operator:
+* NOT: Exactly one field
+* All other operators: Two or more fields
+
+### Boolean Operator
+
+Choose the logical operation to perform:
+
+* **AND**: True only if all inputs are true
+  * Use for: Requiring all conditions
+  * Example: All safety switches must be on
+
+* **OR**: True if any input is true
+  * Use for: Accepting any condition
+  * Example: Any warning condition is active
+
+* **NOT**: Inverts the input value
+  * Use for: Negating conditions
+  * Example: Invert a status flag
+
+* **XOR**: True if odd number of inputs are true
+  * Use for: Detecting mismatches
+  * Example: Check if states are different
+
+* **XNOR**: True if even number of inputs are true
+  * Use for: Detecting matches
+  * Example: Verify state agreement
+
+* **NOR**: True only if all inputs are false
+  * Use for: Detecting inactive states
+  * Example: Check if all systems are off
+
 ## Output
 
-Outputs the incoming event while appending the result (``boolean-operations-result``) to the incoming event.
+The processor creates a new event containing:
+* All original fields from the input event
+* A new boolean field named "boolean-operations-result" with the result of the logical operation
+
+### Example
+
+#### Input Event
+```json
+{
+  "deviceId": "machine01",
+  "safetySwitch1": true,
+  "safetySwitch2": true,
+  "emergencyStop": false,
+  "timestamp": 1586380104915
+}
+```
+
+#### Configuration 1: AND Operation
+* Properties: safetySwitch1, safetySwitch2
+* Operator: AND
+
+#### Output Event
+```json
+{
+  "deviceId": "machine01",
+  "safetySwitch1": true,
+  "safetySwitch2": true,
+  "emergencyStop": false,
+  "timestamp": 1586380104915,
+  "boolean-operations-result": true
+}
+```
+
+#### Configuration 2: NOT Operation
+* Properties: emergencyStop
+* Operator: NOT
+
+#### Output Event
+```json
+{
+  "deviceId": "machine01",
+  "safetySwitch1": true,
+  "safetySwitch2": true,
+  "emergencyStop": false,
+  "timestamp": 1586380104915,
+  "boolean-operations-result": true
+}
+```
+
+## Use Cases
+
+1. **Safety Systems**
+   * Combine multiple safety interlocks
+   * Monitor emergency conditions
+   * Implement fail-safe logic
+   * Validate safety states
+   * Create composite safety checks
+
+2. **Process Control**
+   * Combine process conditions
+   * Implement control logic
+   * Monitor state combinations
+   * Create decision points
+   * Build process interlocks
+
+3. **Quality Monitoring**
+   * Combine quality checks
+   * Implement acceptance criteria
+   * Monitor multiple conditions
+   * Create composite quality states
+   * Build validation rules
+
+4. **System Monitoring**
+   * Combine status indicators
+   * Monitor system states
+   * Implement health checks
+   * Create alert conditions
+   * Build diagnostic rules
+
+## Notes
+
+* All input fields must be boolean
+* NOT operator requires exactly one input field
+* All other operators require at least two input fields
+* Operations are evaluated left-to-right
+* Result is always boolean
+* Null inputs are treated as false
+* The output field is always named "boolean-operations-result"
+* Processing is stateless
+* Multiple operations require chaining processors
+* Consider operation precedence in complex logic
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.timekeeping/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.timekeeping/documentation.md
index a4adacf1b3..e5ddc1f82b 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.timekeeping/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.timekeeping/documentation.md
@@ -26,39 +26,116 @@
 
 ## Description
 
-This processor can be used to measure the time between two boolean sensors.
-For example on a conveyor, where one sensor is placed on the left and one senor placed on the right.
-Parts are transported on the conveyor and the sensors are boolean sensors detecting those parts.
-The time is measured between the two sensors as well as the amount of complete transportation's is counted.
-The measurement is initialized once the left sensor is true and stopped once the right sensor is true.
-There can also be multiple parts on the conveyor as long as the individual parts do not change.
+The Measure Time Between Two Sensors processor calculates the time difference between two boolean signals. It supports:
+* Signal timing measurement
+* Event sequence tracking
+* Time difference calculation
+* Signal counting
+* Multiple time units (milliseconds, seconds, minutes)
+
+This processor is essential for:
+* Measuring process times
+* Tracking signal sequences
+* Analyzing delays
+* Monitoring performance
 
+***
 
-<p align="center">
-    <img src="time_measure_example.png" width="300px;" class="pe-image-documentation"/>
-</p>
+## Required input
+
+The processor requires a data stream containing:
+* A left boolean field (start signal)
+* A right boolean field (end signal)
 
 ***
 
-## Required input
-Requires two boolean fields in the datastream.
+## Configuration
 
 ### Left Field
-The left field starts the timer when value is true.
+
+Select the boolean field that starts the timer. This signal marks the beginning of the time measurement.
 
 ### Right Field
-The right field stops the timer and emits the event when its value is true.
 
-***
+Select the boolean field that ends the timer. This signal triggers the output event with the measured time.
 
-## Configuration
-No furhter configuration is required.
+### Output Unit
 
-## Output
-Appends two fields to the input event.
+Choose the time unit for the output:
+* **Milliseconds**: Raw time difference
+* **Seconds**: Time difference divided by 1000
+* **Minutes**: Time difference divided by 60000
 
-### Timer Field
-The timer field is a numeric value representing the time between the two sensors. Runtime name: measured_time
+## Output
 
-### Counter
-The counter indicated how many events where emitted by this component. Runtime name: counter
\ No newline at end of file
+The processor creates a new event containing:
+* All original fields from the input event
+* A "measured_time" field showing the time between signals in the selected unit
+* A "counter" field showing the number of completed measurements
+
+### Example
+
+#### Input Event Stream
+```json
+[
+  {
+    "deviceId": "machine01",
+    "timestamp": 1586380104915,
+    "startSignal": false,
+    "endSignal": false
+  },
+  {
+    "deviceId": "machine01",
+    "timestamp": 1586380105015,
+    "startSignal": true,
+    "endSignal": false
+  },
+  {
+    "deviceId": "machine01",
+    "timestamp": 1586380105115,
+    "startSignal": true,
+    "endSignal": true
+  }
+]
+```
+
+#### Configuration
+* Left Field: startSignal
+* Right Field: endSignal
+* Output Unit: Seconds
+
+#### Output Event
+```json
+{
+  "deviceId": "machine01",
+  "timestamp": 1586380105115,
+  "startSignal": true,
+  "endSignal": true,
+  "measured_time": 1.0,
+  "counter": 1
+}
+```
+
+## Use Cases
+
+1. **Process Timing**
+   * Measure process cycle times
+   * Track signal sequences
+   * Analyze delays
+   * Monitor performance
+
+2. **Performance Analysis**
+   * Measure response times
+   * Track operation sequences
+   * Analyze system delays
+   * Monitor equipment performance
+
+## Notes
+
+* Only boolean fields can be monitored
+* Processing is stateful
+* Time measurement is based on system time
+* Counter resets at Long.MAX_VALUE
+* Multiple start signals are buffered
+* Output is triggered by end signal
+* Original event fields are preserved
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.timer/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.timer/documentation.md
index 30ee61eb0a..9e81772c0f 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.timer/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.booloperator.timer/documentation.md
@@ -26,27 +26,131 @@
 
 ## Description
 
-This processor measures how long a boolean value does not change.
-Once the value is changes the event with the measured time is emitted.
+The Boolean Timer processor measures the duration that a boolean field maintains a specific state. It supports:
+* Measuring TRUE state duration
+* Measuring FALSE state duration
+* Multiple time units (milliseconds, seconds, minutes)
+* State change detection
+* Duration tracking
 
+This processor is essential for:
+* Measuring state durations
+* Monitoring active/inactive times
+* Tracking operation periods
+* Calculating cycle times
 
 ***
 
 ## Required input
 
-A boolean value is required in the data stream.
-
-### Field
-
-The boolean field which is monitored for state changes.
+The processor requires a data stream containing at least one boolean field to measure its state duration.
 
 ***
 
 ## Configuration
 
-### Timer value
-Define whether it should be measured how long the value is true or how long the value is false.
+### Boolean Field
+
+Select the boolean field to monitor for state duration. This field will be used to measure how long it maintains a specific state.
+
+### Value to Observe
+
+Choose which state to measure the duration for:
+
+* **TRUE**: Measure how long the field stays true
+  * Use for: Measuring active periods
+  * Example: Machine runtime
+
+* **FALSE**: Measure how long the field stays false
+  * Use for: Measuring inactive periods
+  * Example: Downtime duration
+
+### Output Unit
+
+Select the time unit for the measured duration:
+
+* **Milliseconds**: Raw millisecond values
+  * Use for: Precise timing
+  * Example: Response time measurement
+
+* **Seconds**: Duration in seconds (milliseconds / 1000)
+  * Use for: General timing
+  * Example: Process duration
+
+* **Minutes**: Duration in minutes (milliseconds / 60000)
+  * Use for: Long periods
+  * Example: Operation time
 
 ## Output
-Appends a field with the time how long the value did not change.
-Is emitted on the change of the boolean value. Runtime name: measured_time
+
+The processor creates a new event containing:
+* All original fields from the input event
+* A new field named "measured_time" containing the duration in the selected unit
+
+### Example
+
+#### Input Event Stream
+```json
+[
+  {
+    "deviceId": "machine01",
+    "isRunning": false,
+    "timestamp": 1586380104915
+  },
+  {
+    "deviceId": "machine01",
+    "isRunning": true,
+    "timestamp": 1586380105915
+  },
+  {
+    "deviceId": "machine01",
+    "isRunning": true,
+    "timestamp": 1586380106915
+  },
+  {
+    "deviceId": "machine01",
+    "isRunning": false,
+    "timestamp": 1586380107915
+  }
+]
+```
+
+#### Configuration 1: TRUE State in Seconds
+* Boolean Field: isRunning
+* Value to Observe: TRUE
+* Output Unit: Seconds
+
+#### Output Event
+```json
+{
+  "deviceId": "machine01",
+  "isRunning": false,
+  "timestamp": 1586380107915,
+  "measured_time": 2.0
+}
+```
+
+## Use Cases
+
+1. **Equipment Monitoring**
+   * Measure machine runtime
+   * Track downtime periods
+   * Monitor active states
+   * Calculate cycle times
+
+2. **Process Control**
+   * Measure process duration
+   * Track state changes
+   * Monitor operation times
+   * Calculate response times
+
+## Notes
+
+* Only boolean fields can be measured
+* Processing is stateful
+* Time measurement is based on system time
+* Measurement starts when selected state is detected
+* Measurement ends when opposite state is detected
+* Output is only generated when measurement ends
+* Time units are automatically converted
+* Original event fields are preserved
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.changed-value/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.changed-value/documentation.md
index 5a4b55ce34..b76ae34f5f 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.changed-value/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.changed-value/documentation.md
@@ -26,15 +26,96 @@
 
 ## Description
 
-This processor sends out an event everytime a specific object changes.
-It also adds a timestamp in ms from the system time.
+The Value Changed processor detects changes in field values and outputs events only when changes occur. It supports:
+* Any data type comparison
+* Dimension-based state tracking
+* Change timestamp tracking
+* State size management
+* Multi-dimensional monitoring
+
+This processor is essential for:
+* Detecting value changes
+* Tracking state transitions
+* Monitoring field updates
+* Building change logs
+* Implementing change triggers
+
+***
+
+## Required input
+
+The processor requires a data stream containing at least one field to monitor for changes.
 
 ***
 
 ## Configuration
-Select property to monitor for changes
 
-Describe the configuration parameters here
+### Keep Fields
+
+Select the field to monitor for changes. The processor will output an event only when the selected field's value changes.
 
 ## Output
-Emit an event on change and append a timestamp when the change occured
\ No newline at end of file
+
+The processor creates a new event containing:
+* All original fields from the input event
+* A new field named "change_detected" containing the timestamp when the change occurred
+* Only when the monitored field changes value
+
+### Example
+
+#### Input Event Stream
+```json
+{
+  "deviceId": "sensor01",
+  "location": "l1",
+  "value": 12,
+  "timestamp": 1586380104915
+}
+```
+```json
+{
+  "deviceId": "sensor01",
+  "location": "l1",
+  "value": 15,
+  "timestamp": 1586380105015
+}
+```
+
+#### Configuration
+* Keep Fields: value
+
+#### Output Event
+```json
+{
+  "deviceId": "sensor01",
+  "location": "l1",
+  "value": 15,
+  "timestamp": 1586380105015,
+  "change_detected": 1586380105015
+}
+```
+
+## Use Cases
+
+1. **Change Detection**
+   * Monitor value changes
+   * Track state transitions
+   * Detect field updates
+   * Build change logs
+
+2. **State Monitoring**
+   * Track state changes
+   * Monitor transitions
+   * Detect updates
+   * Log changes
+
+## Notes
+
+* Supports any data type
+* Processing is stateful
+* State size limited to 5000 entries
+* Events only emitted on value changes
+* Original fields are preserved
+* Change timestamps are added
+* Dimension-based state tracking
+* Multi-dimensional monitoring supported
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.count-array/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.count-array/documentation.md
index 1e006e60ac..2671afb072 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.count-array/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.count-array/documentation.md
@@ -26,24 +26,80 @@
 
 ## Description
 
-This processor takes a list field, computes the size of the list and appends the result to the event.
+The Count Array processor counts the number of elements in array/list fields. It supports:
+* Array size counting
+* List length measurement
+* Collection size tracking
+* Dynamic array handling
+
+This processor is essential for:
+* Measuring array sizes
+* Tracking list lengths
+* Monitoring collection growth
+* Analyzing data volumes
 
 ***
 
 ## Required input
 
-This processor works with any event that has a field of type ``list``.
+The processor requires a data stream containing at least one array or list field to count its elements.
 
 ***
 
 ## Configuration
 
-Describe the configuration parameters here
-
 ### List Field
 
-The field containing the list that should be used.
+Select the array or list field to count its elements. This field will be used to determine the number of items it contains.
 
 ## Output
 
-Outputs the incoming event while appending the list size (named ``countValue``) to the incoming event.
\ No newline at end of file
+The processor creates a new event containing:
+* All original fields from the input event
+* A new field named "countValue" containing the number of elements in the selected array/list
+
+### Example
+
+#### Input Event
+```json
+{
+  "deviceId": "sensor01",
+  "measurements": [23.5, 24.1, 25.3, 24.8],
+  "timestamp": 1586380104915
+}
+```
+
+#### Configuration
+* List Field: measurements
+
+#### Output Event
+```json
+{
+  "deviceId": "sensor01",
+  "measurements": [23.5, 24.1, 25.3, 24.8],
+  "timestamp": 1586380104915,
+  "countValue": 4
+}
+```
+
+## Use Cases
+
+1. **Data Analysis**
+   * Count array elements
+   * Track list sizes
+   * Monitor collection growth
+   * Measure data volumes
+
+2. **Resource Management**
+   * Monitor buffer sizes
+   * Track queue lengths
+   * Measure storage usage
+   * Analyze capacity needs
+
+## Notes
+
+* Only array/list fields can be counted
+* Count is calculated per event
+* Processing is stateless
+* Empty arrays return 0
+* Null arrays are not supported
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.csvmetadata/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.csvmetadata/documentation.md
index 9080e2d091..a624d088ec 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.csvmetadata/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.csvmetadata/documentation.md
@@ -16,56 +16,121 @@
   ~
   -->
 
-## CSV Metadata Enrichment
-Enrich a datastream with information provided in a CSV file.
-The data of the CSV file is matched by an id column with a property value of a String in the data stream.
+## CSV Metadata Enricher
+
+<p align="center">
+    <img src="icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
 
 ***
 
 ## Description
-Upload a CSV file with static meta information that will be appended to each event.
-The file can contain different information for different keys in the stream.
 
+The CSV Metadata Enricher processor adds additional fields to events by looking up values in a CSV file. It supports:
+* CSV file integration
+* Field mapping
+* ID-based lookups
+* Multiple field enrichment
+* Static metadata
+
+This processor is essential for:
+* Adding static metadata
+* Enriching event data
+* Mapping reference data
+* Creating data relationships
+
+***
 
-### Structure of CSV file
-The first row containes the runtime names for the properties to insert.
-Once the file is uploaded the user can select which column to use for the matching property
-and which values should be appended.
-Delimiter: ';'
+## Required input
 
+The processor requires:
+* A data stream containing an ID field for lookups
+* A CSV file containing the metadata to be added
+* A field in the CSV file that matches the ID field
 
 ***
 
-## Example
-Add the location of a production line to the event
+## Configuration
 
-### Input  event
-```
+### ID Field
+
+Select the field from the input event that will be used to look up matching records in the CSV file.
+
+### CSV File
+
+Upload the CSV file containing the metadata to be added to the events. The file should contain:
+* A column that matches the ID field
+* Additional columns with the metadata to be added
+
+### Field to Match
+
+Select the column name in the CSV file that corresponds to the ID field. This field will be used to find matching records.
+
+### Fields to Append
+
+Select one or more columns from the CSV file that should be added to the events. These fields will be appended to the output events.
+
+## Output
+
+The processor creates a new event containing:
+* All original fields from the input event
+* The selected fields from the CSV file for matching records
+
+### Example
+
+#### Input Event
+```json
 {
-  'line_id': 'line1',
-  'timestamp': 1586378041
+  "deviceId": "sensor01",
+  "temperature": 23.5,
+  "timestamp": 1586380104915
 }
 ```
 
-### CSV File
-```
-production_line;location
-line1;germany
-line2;uk
-line3;usa
+#### CSV File Content
+```csv
+device_id,location,manufacturer,model
+sensor01,Building A,Acme Corp,TempPro 2000
+sensor02,Building B,Acme Corp,TempPro 2000
 ```
 
-### Configuration
-* The field that is used for the lookup (Example: line_id)
-* The CSV file (Example: Upload the csv file)
-* Field to match (Example: production_line)
-* Fields to append (Example: location)
+#### Configuration
+* ID Field: deviceId
+* Field to Match: device_id
+* Fields to Append: location, manufacturer, model
 
-### Output event
-```
+#### Output Event
+```json
 {
-  'line_id': 'line1',
-  'timestamp': 1586378041,
-  'location': 'germany'
+  "deviceId": "sensor01",
+  "temperature": 23.5,
+  "timestamp": 1586380104915,
+  "location": "Building A",
+  "manufacturer": "Acme Corp",
+  "model": "TempPro 2000"
 }
 ```
+
+## Use Cases
+
+1. **Device Management**
+   * Add device metadata
+   * Map locations
+   * Track equipment info
+   * Monitor assets
+
+2. **Data Enrichment**
+   * Add reference data
+   * Map relationships
+   * Create context
+   * Build hierarchies
+
+## Notes
+
+* CSV file must be uploaded
+* ID field must exist in both event and CSV
+* Field names are case-sensitive
+* CSV must have a header row
+* No matches return empty values
+* Processing is stateless
+* CSV is loaded at startup
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.datetime/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.datetime/documentation.md
index 3dfcb6657f..b4b4804ed0 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.datetime/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.datetime/documentation.md
@@ -24,49 +24,89 @@
 
 ***
 
-## Overview
+## Description
 
-The "Datetime From String" processor is a handy tool that helps convert human-readable datetime information into a
-format that machines can understand. This is particularly useful when dealing with data that includes dates and times.
+The Datetime From String processor converts string timestamps into millisecond timestamps. It supports:
+* ISO 8601 format parsing
+* Timezone handling
+* String to millisecond conversion
+* Automatic timezone application
 
-### Why Use This Processor?
-
-In the context of event streams, you may encounter dates and times formatted for human readability but not necessarily
-optimized for computer processing. The "Datetime From String" processor addresses this by facilitating the conversion
-of human-readable datetime information within your continuous stream of events.
+This processor is essential for:
+* Converting timestamps to milliseconds
+* Standardizing date formats
+* Handling timezone conversions
+* Processing ISO 8601 dates
 
 ***
 
-## How It Works
-
-When you input a data stream into this processor containing a datetime in a specific format (such as "2023-11-24 15:30:
-00"), it
-undergoes a transformation. The processor converts it into a computer-friendly format called a ZonedDateTime object.
-
-### Example
+## Required input
 
-Let's say you have an event stream with a property containing values like "2023-11-24 15:30:00" and you want to make
-sure your computer understands it. You can use
-this processor to convert it into a format that's machine-friendly.
+The processor requires a data stream containing at least one string field with a timestamp in ISO 8601 format.
 
 ***
 
-## Getting Started
+## Configuration
 
-To use this processor, you need one thing in your data:
+### DateTime String
 
-1. **Datetime String**: This is the name of the event property that contains the human-readable datetime string, like "2023-11-24 15:30:00".
+Select the field containing the timestamp string. The string should be in ISO 8601 format (e.g., '2023-11-29T18:30:22' or '2023-11-29T18:30:22+01:00').
 
+### Time Zone
 
-### Configuration
-
-The only thing you need to configure is the time zone.
-1. **Time Zone**: Specify the time zone that applies to your datetime if it doesn't already have this information.This ensures that the processor understands the context of your
-datetime.
+Select the timezone for the input timestamp. This is used when the timestamp string doesn't include timezone information. If the input string already contains timezone information, this setting is ignored.
 
 ## Output
 
-After the conversion happens, the processor adds a new piece of information to your data stream:
+The processor creates a new event containing:
+* All original fields from the input event
+* A new field named "timestringInMillis" containing the timestamp in milliseconds since epoch
+* A new field named "timeZone" containing the selected timezone
+
+### Example
 
-* **timestringInMillis**: This is the transformed datetime in a format that computers can easily work with (UNIX timestamp in milliseconds).
-* **timeZone**: The name of the timezone the `dateTime` value refers to. Can be used to reconstitute the actual time.
\ No newline at end of file
+#### Input Event
+```json
+{
+  "deviceId": "sensor01",
+  "timestamp": "2023-11-29T18:30:22",
+  "value": 23.5
+}
+```
+
+#### Configuration
+* DateTime String: timestamp
+* Time Zone: UTC
+
+#### Output Event
+```json
+{
+  "deviceId": "sensor01",
+  "timestamp": "2023-11-29T18:30:22",
+  "value": 23.5,
+  "timestringInMillis": 1701279022000,
+  "timeZone": "UTC"
+}
+```
+
+## Use Cases
+
+1. **Data Standardization**
+   * Convert timestamps to milliseconds
+   * Standardize date formats
+   * Handle timezone conversions
+   * Process ISO 8601 dates
+
+2. **System Integration**
+   * Map timestamps to milliseconds
+   * Convert between timezones
+   * Standardize date formats
+   * Process time-based data
+
+## Notes
+
+* Input must be in ISO 8601 format
+* Timezone in input string takes precedence over selected timezone
+* Invalid formats will cause processing errors
+* Processing is stateless
+* Output is always in milliseconds since epoch
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.duration-value/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.duration-value/documentation.md
index 6a214ad016..8c40746a75 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.duration-value/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.duration-value/documentation.md
@@ -26,20 +26,96 @@
 
 ## Description
 
-This processor calculates the duration for a given stream with a start timestamp and an end timestamp.
+The Calculate Duration processor computes the time difference between two timestamps. It supports:
+* Time difference calculation
+* Multiple time units
+* Start/end timestamp selection
+* Duration measurement
+
+This processor is essential for:
+* Measuring time periods
+* Calculating durations
+* Analyzing intervals
+* Tracking time spans
 
 ***
 
 ## Required input
-Two timestamp fields
+
+The processor requires a data stream containing at least two timestamp fields to calculate the duration between them.
 
 ***
 
 ## Configuration
 
-* Start Timestamp: The first timestamp (t1)
-* End Timestamp: The second timestamp (t2)
-* Time Unit of the result
+### Start Timestamp
+
+Select the field containing the start timestamp. This timestamp marks the beginning of the duration period.
+
+### End Timestamp
+
+Select the field containing the end timestamp. This timestamp marks the end of the duration period.
+
+### Time Unit
+
+Select the unit for the calculated duration:
+* Milliseconds (default)
+* Seconds
+* Minutes
 
 ## Output
-Appends a new field with the difference of t2 and t1
\ No newline at end of file
+
+The processor creates a new event containing:
+* All original fields from the input event
+* A new field named "duration" containing the calculated time difference in the selected unit
+
+### Example
+
+#### Input Event
+```json
+{
+  "deviceId": "machine01",
+  "startTime": 1586380104915,
+  "endTime": 1586380105915,
+  "operation": "process1"
+}
+```
+
+#### Configuration
+* Start Timestamp: startTime
+* End Timestamp: endTime
+* Time Unit: Seconds
+
+#### Output Event
+```json
+{
+  "deviceId": "machine01",
+  "startTime": 1586380104915,
+  "endTime": 1586380105915,
+  "operation": "process1",
+  "duration": 1.0
+}
+```
+
+## Use Cases
+
+1. **Process Monitoring**
+   * Measure process duration
+   * Track operation times
+   * Monitor cycle times
+   * Calculate periods
+
+2. **Performance Analysis**
+   * Measure response times
+   * Track execution times
+   * Monitor durations
+   * Calculate intervals
+
+## Notes
+
+* Both timestamps must be present
+* Timestamps must be valid
+* End time must be after start time
+* Processing is stateless
+* Multiple durations require chaining
+* Negative durations are not supported
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.field-mapper/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.field-mapper/documentation.md
index 2e86d36776..836c78ccbb 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.field-mapper/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.field-mapper/documentation.md
@@ -26,43 +26,93 @@
 
 ## Description
 
-Replaces one or more fields with a new field and computes a hash value of these fields
+The Field Mapper processor combines multiple fields into a single field by computing an MD5 hash value of their combined contents. This processor is particularly useful for:
+
+* Creating unique identifiers from multiple fields
+* Data anonymization and privacy protection
+* Reducing data dimensionality
+* Generating consistent keys for data grouping
+* Combining related fields into a single reference
 
 ***
 
-## Configuration
+## Required input
 
-* Fields: Fields that will be mapped into a property
-* Name of the new field
+The processor can work with any event that contains at least one field. The fields to be mapped can be of any data type, as they will be converted to their string representation before hashing.
 
 ***
 
-## Example
+## Configuration
 
-Merge two fields into a hash value
+### Fields
 
-### Input  event
+Select one or more fields that should be combined into a single hash value. The order of field selection matters, as it affects the resulting hash value.
 
-```
+### New Field Name
+
+Specify the name of the new field that will contain the MD5 hash value of the combined fields.
+
+## Output
+
+The processor creates a new event that:
+* Retains all fields from the input event that were not selected for mapping
+* Adds a new field with the specified name containing the MD5 hash of the combined selected fields
+* Removes the original fields that were mapped
+
+### Example
+
+#### Input Event
+```json
 {
-  "timestamp":1586380104915,
-  "mass_flow":4.3167,
-  "temperature":40.05,
-  "sensorId":"flowrate01"
+  "timestamp": 1586380104915,
+  "mass_flow": 4.3167,
+  "temperature": 40.05,
+  "pressure": 1013.25,
+  "sensorId": "flowrate01"
 }
 ```
 
-### Configuration
-
+#### Configuration
 * Fields: mass_flow, temperature
-* Name of new field: demo
+* New Field Name: combined_measurement
 
-### Output event
-
-```
+#### Output Event
+```json
 {
-  "timestamp":1586380104915,
-  "sensorId":"flowrate01"
-  "demo":"8ae11f5c83610104408d485b73120832",
+  "timestamp": 1586380104915,
+  "pressure": 1013.25,
+  "sensorId": "flowrate01",
+  "combined_measurement": "8ae11f5c83610104408d485b73120832"
 }
-```
\ No newline at end of file
+```
+
+## Use Cases
+
+1. **Data Privacy**
+   * Combine personally identifiable information (PII) into anonymized identifiers
+   * Create privacy-preserving keys for data linkage
+   * Generate pseudonyms for sensitive data
+
+2. **Data Integration**
+   * Create composite keys for data joining
+   * Generate unique identifiers across systems
+   * Standardize multi-field references
+
+3. **Data Quality**
+   * Track changes across multiple fields
+   * Create checksums for data validation
+   * Monitor data integrity
+
+4. **Performance Optimization**
+   * Reduce storage requirements by combining fields
+   * Optimize indexing with combined keys
+   * Improve query performance with single-field lookups
+
+## Notes
+
+* The hash value is deterministic - the same input fields will always produce the same hash
+* The hash is irreversible - you cannot recover the original field values from the hash
+* Field order matters - changing the order of fields will produce a different hash
+* All field values are converted to strings before hashing
+* The output hash is always a 32-character hexadecimal string
+* Null or empty field values are handled gracefully but will affect the resulting hash
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.fieldhasher/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.fieldhasher/documentation.md
index 30d72fa7c2..3fbbb8912c 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.fieldhasher/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.fieldhasher/documentation.md
@@ -26,24 +26,72 @@
 
 ## Description
 
-The Field Hasher uses an algorithm to encode values in a field.
-The Field Hasher can use MD5, SHA1 or SHA2 to hash field values.
+The Field Hasher processor is a data transformation component that applies cryptographic hash functions to string values in a data stream. It can be used to encode sensitive information, generate unique identifiers, or transform data for privacy and security purposes.
+
+The processor supports three widely-used hash algorithms:
+* **MD5** - A 128-bit hash function
+* **SHA1** - A 160-bit hash function
+* **SHA2** - A 256-bit hash function (SHA-256 implementation)
 
 ***
 
 ## Required input
-This processor requires at least one field of type string.
+
+This processor requires an event stream that contains at least one field of type string. The string field will be used as input for the hash function.
 
 ***
 
 ## Configuration
 
 ### Field
-Specifies the string field that will be encoded.
+Specifies the string field that will be encoded. This field must exist in the input event stream and must contain string values.
 
 ### Hash Algorithm
-Specifies the algorithm used to encode the string field. The following algorithms
-are available: SHA2, MD5 or SHA1.
+Select the hash algorithm to use for encoding the string field. Available options are:
+* **SHA1** - Produces a 40-character hexadecimal hash
+* **SHA2** - Produces a 64-character hexadecimal hash
+* **MD5** - Produces a 32-character hexadecimal hash
 
 ## Output
-The encoded string field.
\ No newline at end of file
+
+The processor modifies the input event by replacing the value of the selected field with its hashed version. All other fields in the event remain unchanged.
+
+### Example
+
+#### Input Event
+```json
+{
+  "timestamp": 1617183834000,
+  "sensorId": "sensor123",
+  "value": 42.5,
+  "user": "john.doe@example.com"
+}
+```
+
+#### Configuration
+* Field: user
+* Hash Algorithm: MD5
+
+#### Output Event
+```json
+{
+  "timestamp": 1617183834000,
+  "sensorId": "sensor123",
+  "value": 42.5,
+  "user": "e87f955d3b3499b8b13e901fd61b6b64"
+}
+```
+
+## Use Cases
+
+1. **Privacy Protection**: Hash personally identifiable information (PII) before storage or transmission
+2. **Data Anonymization**: Create anonymous identifiers from user data
+3. **Checksum Generation**: Generate checksums for data validation
+4. **Unique ID Creation**: Create unique identifiers from combinations of fields
+
+## Notes
+
+* The hash functions are one-way transformations - the original value cannot be recovered from the hash
+* The same input will always produce the same hash value
+* Different hash algorithms provide different levels of collision resistance and output lengths
+* For security-critical applications, consider using SHA2 as it provides stronger cryptographic properties
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.fieldrename/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.fieldrename/documentation.md
index 059b08ae8f..421859b1f5 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.fieldrename/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.fieldrename/documentation.md
@@ -18,36 +18,95 @@
 
 ## Field Renamer
 
+<p align="center">
+    <img src="icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
 
 ***
 
 ## Description
 
-Replaces the runtime name of an event property with a custom defined name.
-Useful for data ingestion purposes where a specific event schema is required.
+The Field Renamer processor changes the name of fields in events. It supports:
+* Single field renaming
+* Custom field names
+* Runtime name modification
+* Field name standardization
 
+This processor is essential for:
+* Standardizing field names
+* Creating consistent naming
+* Mapping field identifiers
+* Improving readability
 
 ***
 
-### OldFieldName
-Specifies the field to rename.
+## Required input
 
-### NewFieldName
-Specifies the new runtime name of the field.
+The processor requires a data stream containing at least one field to rename.
+
+***
+
+## Configuration
+
+### Field
+
+Select the field to rename. This field's name will be changed in the output event.
+
+### New Field Name
+
+Enter the new name for the selected field. This name will replace the original field name in the output event.
 
 ## Output
-Example:
 
-Old Output:
-```
+The processor creates a new event containing:
+* All original fields from the input event
+* The selected field with its new name
+* All field values remain unchanged
+
+### Example
+
+#### Input Event
+```json
 {
-  'timestamp': 16003000,
+  "deviceId": "sensor01",
+  "temp": 23.5,
+  "humidity": 45.2,
+  "timestamp": 1586380104915
 }
 ```
 
-New Ouput:
-```
+#### Configuration
+* Field: temp
+* New Field Name: temperature
+
+#### Output Event
+```json
 {
-  'time': 16003000,
+  "deviceId": "sensor01",
+  "temperature": 23.5,
+  "humidity": 45.2,
+  "timestamp": 1586380104915
 }
-```
\ No newline at end of file
+```
+
+## Use Cases
+
+1. **Data Standardization**
+   * Standardize field names
+   * Create naming conventions
+   * Map field identifiers
+   * Improve consistency
+
+2. **System Integration**
+   * Map field names
+   * Standardize interfaces
+   * Create consistency
+   * Build mappings
+
+## Notes
+
+* Only field names are changed
+* Field values remain unchanged
+* Original field order is preserved
+* Processing is stateless
+* Multiple renames require chaining
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.measurementunitconverter/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.measurementunitconverter/documentation.md
index 9d0b81b28c..73ad466d96 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.measurementunitconverter/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.measurementunitconverter/documentation.md
@@ -26,22 +26,114 @@
 
 ## Description
 
-Converts a unit of measurement to another one.
+The Measurement Unit Converter processor automatically converts values between different units of measurement. It supports any unit type that is compatible with the input field's measurement unit, including:
+
+* Length (meters, feet, inches, etc.)
+* Mass (kilograms, pounds, ounces, etc.)
+* Temperature (Celsius, Fahrenheit, Kelvin)
+* Volume (liters, gallons, cubic meters, etc.)
+* Pressure (Pascal, bar, PSI, etc.)
+* Speed (m/s, km/h, mph, etc.)
+* Area (square meters, acres, etc.)
+* Time (seconds, minutes, hours, etc.)
+* Energy (joules, kilowatt-hours, etc.)
+* Power (watts, horsepower, etc.)
+
+This processor is essential for:
+* Standardizing measurements across systems
+* Converting between international and US units
+* Ensuring consistent data representation
+* Supporting multi-regional deployments
+* Enabling system interoperability
 
 ***
 
 ## Required input
 
+The processor requires:
+1. A numerical field that has a measurement unit defined
+2. The field must be of type measurement property
 
 ***
 
 ## Configuration
 
-Describe the configuration parameters here
+### Field
+
+Select the numerical field containing the value to convert. The field must have a measurement unit defined.
+
+### Output Unit
+
+Select the desired unit of measurement for the output value. The available units are dynamically populated based on the input field's measurement unit type.
+
+## Output
+
+The processor creates a new event containing:
+* All original fields from the input event
+* The selected field is updated with the converted value
+
+### Example
+
+#### Input Event
+```json
+{
+  "sensorId": "temp01",
+  "temperature": 20.0,
+  "humidity": 65,
+  "timestamp": 1586380104915
+}
+```
+
+#### Configuration
+* Field: temperature (with unit Celsius)
+* Output Unit: Fahrenheit
+
+#### Output Event
+```json
+{
+  "sensorId": "temp01",
+  "temperature": 68.0,
+  "humidity": 65,
+  "timestamp": 1586380104915
+}
+```
+
+## Use Cases
+
+1. **International Operations**
+   * Convert between metric and imperial units
+   * Standardize measurements across regions
+   * Support global data analysis
+   * Enable multi-market compliance
+
+2. **System Integration**
+   * Convert between different system standards
+   * Normalize data from multiple sources
+   * Enable cross-platform compatibility
+   * Support legacy system integration
 
-### 1st parameter
+3. **Scientific Applications**
+   * Convert between scientific units
+   * Support experimental data analysis
+   * Enable cross-discipline collaboration
+   * Maintain measurement precision
 
+4. **Industrial Processes**
+   * Convert process measurements
+   * Standardize control parameters
+   * Support equipment interoperability
+   * Enable cross-vendor integration
 
-### 2nd parameter
+## Notes
 
-## Output
\ No newline at end of file
+* The input field must have a measurement unit defined
+* Only compatible units are available for selection
+* The conversion is performed in-place
+* The original value is replaced with the converted value
+* All conversions maintain numerical precision
+* Conversion formulas follow international standards
+* Invalid unit combinations are rejected
+* Null values are preserved in output
+* Conversion is stateless
+* Conversion accuracy depends on input precision
+* Temperature conversions handle both relative and absolute scales
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.booloperator.edge/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.booloperator.edge/documentation.md
index 776a949eca..854df1b649 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.booloperator.edge/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.booloperator.edge/documentation.md
@@ -16,7 +16,7 @@
   ~
   -->
 
-##  Signal Edge Filter
+## Signal Edge Filter
 
 <p align="center">
     <img src="icon.png" width="150px;" class="pe-image-documentation"/>
@@ -26,27 +26,155 @@
 
 ## Description
 
-Observes a boolean value and forwards the event when a signal edge is detected
+The Signal Edge Filter processor detects and forwards events when a boolean signal changes state (edge detection). It supports:
+* Rising edge detection (FALSE -> TRUE)
+* Falling edge detection (TRUE -> FALSE)
+* Both edge detection
+* Configurable delay
+* Event selection options
+
+This processor is essential for:
+* Detecting state transitions
+* Monitoring signal changes
+* Triggering actions on state changes
+* Implementing edge-triggered logic
 
 ***
 
 ## Required input
 
-### Boolean Field
-Boolean field that is observed
+The processor requires a data stream containing at least one boolean field to monitor for state changes.
 
 ***
 
 ## Configuration
-### Kind of edge
-* Detect rising edges
-* Detect falling edges
-* Detect both
+
+### Boolean Signal
+
+Select the boolean field to monitor for state changes. This field will be used to detect signal edges.
+
+### Signal Edge
+
+Choose the type of edge to detect:
+
+* **FALSE -> TRUE**: Rising edge detection
+  * Triggers when signal changes from false to true
+  * Use for: Detecting activation events
+  * Example: Device turned on
+
+* **TRUE -> FALSE**: Falling edge detection
+  * Triggers when signal changes from true to false
+  * Use for: Detecting deactivation events
+  * Example: Device turned off
+
+* **BOTH**: Both edge detection
+  * Triggers on any state change
+  * Use for: Monitoring all transitions
+  * Example: Any state change
 
 ### Delay
-Defines for how many events the signal must be stable before result is emitted.
-(E.g. if set to 2, the result is not emitted if value toggles between true and false,
-it fires when two consecutive events are detected after the flank)
+
+Specify how many events to wait before forwarding the result after an edge is detected:
+* Minimum: 0 (immediate forwarding)
+* Use for: Debouncing signals
+* Example: Wait 5 events to ensure stable state
+
+### Output Event Selection
+
+Choose which event(s) to forward after the delay:
+
+* **First**: Forward only the first event after edge detection
+  * Use for: Single trigger actions
+  * Example: Start a process once
+
+* **Last**: Forward only the last event after delay
+  * Use for: Final state capture
+  * Example: Capture stable state
+
+* **All**: Forward all events during delay
+  * Use for: Continuous monitoring
+  * Example: Track state changes
 
 ## Output
-Emits input event, when the signal edge is detected
+
+The processor creates a new event containing:
+* All original fields from the input event
+* The event is forwarded based on the configured delay and event selection
+
+### Example
+
+#### Input Event Stream
+```json
+[
+  {
+    "deviceId": "sensor01",
+    "isActive": false,
+    "timestamp": 1586380104915
+  },
+  {
+    "deviceId": "sensor01",
+    "isActive": true,
+    "timestamp": 1586380105015
+  },
+  {
+    "deviceId": "sensor01",
+    "isActive": true,
+    "timestamp": 1586380105115
+  }
+]
+```
+
+#### Configuration 1: Rising Edge with First Event
+* Boolean Signal: isActive
+* Signal Edge: FALSE -> TRUE
+* Delay: 0
+* Output Event Selection: First
+
+#### Output Event
+```json
+{
+  "deviceId": "sensor01",
+  "isActive": true,
+  "timestamp": 1586380105015
+}
+```
+
+#### Configuration 2: Both Edges with Last Event
+* Boolean Signal: isActive
+* Signal Edge: BOTH
+* Delay: 1
+* Output Event Selection: Last
+
+#### Output Event
+```json
+{
+  "deviceId": "sensor01",
+  "isActive": true,
+  "timestamp": 1586380105115
+}
+```
+
+## Use Cases
+
+1. **Device Monitoring**
+   * Detect device power state changes
+   * Monitor sensor activation
+   * Track equipment status
+   * Detect system transitions
+
+2. **Process Control**
+   * Trigger actions on state changes
+   * Monitor process transitions
+   * Detect phase changes
+   * Track state machines
+
+## Notes
+
+* Only boolean fields can be monitored
+* Edge detection is stateful
+* Delay is event-based, not time-based
+* Event selection affects output behavior
+* Processing is stateful
+* Edge detection is immediate
+* Delay starts after edge detection
+* Event selection applies after delay
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.booloperator.state/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.booloperator.state/documentation.md
index 34802cd97c..5998fe3830 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.booloperator.state/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.booloperator.state/documentation.md
@@ -16,7 +16,7 @@
   ~
   -->
 
-## Boolean To State
+## Boolean to State
 
 <p align="center">
     <img src="icon.png" width="150px;" class="pe-image-documentation"/>
@@ -26,32 +26,133 @@
 
 ## Description
 
-Converts boolean fields to a state string representing the current state of the system.
-This processor requires one or multiple boolean values in the data stream.
-For the selected value which is true, the runtime name is added as the state field.
+The Boolean to State processor converts boolean fields into a descriptive state string. It supports:
+* Multiple boolean inputs
+* Custom state mapping
+* Default state handling
+* Runtime name mapping
+* JSON configuration
+* State prioritization
+
+This processor is essential for:
+* Converting boolean states
+* Creating descriptive states
+* Mapping boolean values
+* Handling multiple states
+* Building state machines
+* Creating human-readable states
+
 ***
 
 ## Required input
 
-### Boolean Fields
+The processor requires a data stream containing at least one boolean field to convert into a state.
 
-Boolean fields that are converted to the state when true
+***
 
-### Default State
+## Configuration
 
-When all boolean values are false, a default state can be defined
+### Current State
 
-### Mapping Configuration
+Select one or more boolean fields to monitor. When a field is true, its runtime name will be used as the state value. If multiple fields are true, the first one in the list will be used.
 
-Configuration to provide a string mapping for each possible value.
-On the left ist the value of the runtime name and on the right the new value (e.g. {"runtimeName": "newValue"}).
+### Default State
 
-***
+Define a default state string to use when all boolean fields are false. This ensures a state is always present in the output.
 
-## Configuration
+### Mapping Configuration
+
+Define custom mappings to replace the runtime names with your own state strings. Use JSON format:
 
-No further configuration required
+```json
+{
+    "runtimeName1": "Custom State 1",
+    "runtimeName2": "Custom State 2"
+}
+```
 
 ## Output
 
-The output contains a new value with the string values of the state
+The processor creates a new event containing:
+* All original fields from the input event
+* A new field named "current_state" containing the state string
+
+### Example
+
+#### Input Event
+```json
+{
+  "deviceId": "machine01",
+  "isRunning": true,
+  "isError": false,
+  "isMaintenance": false,
+  "timestamp": 1586380104915
+}
+```
+
+#### Configuration
+* Current State: isRunning, isError, isMaintenance
+* Default State: "IDLE"
+* Mapping Configuration:
+```json
+{
+    "isRunning": "OPERATIONAL",
+    "isError": "ERROR",
+    "isMaintenance": "MAINTENANCE"
+}
+```
+
+#### Output Event
+```json
+{
+  "deviceId": "machine01",
+  "isRunning": true,
+  "isError": false,
+  "isMaintenance": false,
+  "timestamp": 1586380104915,
+  "current_state": "OPERATIONAL"
+}
+```
+
+## Use Cases
+
+1. **Equipment Monitoring**
+   * Convert device states
+   * Map status flags
+   * Create state machines
+   * Monitor conditions
+   * Track operations
+
+2. **Process Control**
+   * Map process states
+   * Convert conditions
+   * Create workflows
+   * Monitor phases
+   * Track progress
+
+3. **System Integration**
+   * Map system states
+   * Convert signals
+   * Create interfaces
+   * Monitor status
+   * Track conditions
+
+4. **Quality Control**
+   * Map quality states
+   * Convert checks
+   * Create reports
+   * Monitor tests
+   * Track results
+
+## Notes
+
+* Only boolean fields can be converted
+* State mapping is case-sensitive
+* Default state is required
+* JSON configuration is optional
+* Processing is stateless
+* Multiple states require prioritization
+* Consider state naming
+* Mapping is immediate
+* No delay in processing
+* State is always present
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.state.buffer/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.state.buffer/documentation.md
index e1c87bcbc4..f0311fe452 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.state.buffer/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.state.buffer/documentation.md
@@ -26,29 +26,94 @@
 
 ## Description
 
-Buffers values of a sensor, while state does not change.
-Select a state field in the event. Events are buffered as long as state field does not change.
-When it changes result
-event is emitted.
+The State Buffer processor caches sensor values during specific states. It supports:
+* State-based value buffering
+* Timestamp tracking
+* Sensor value caching
+* State monitoring
+
+This processor is essential for:
+* Caching sensor values
+* Tracking state changes
+* Monitoring conditions
+* Storing measurements
 
 ***
 
 ## Required input
 
-Define the state and sensor value field
+The processor requires a data stream containing:
+* A timestamp field
+* A state field
+* At least one sensor value field to cache
+
+***
+
+## Configuration
 
 ### Timestamp
 
-A mapping property for a timestamp field
+Select the field containing the event timestamp. This is used to track when values are buffered.
 
 ### State
 
-Select the field representing the state
+Select the field containing the state information. This determines when values are cached.
 
-### Sensor value to cache
+### Sensor Value to Cache
 
-Select the field with the numerical values to buffer
+Select the sensor value field that should be cached while the state is active.
 
 ## Output
 
-Emits a new event on state change, with the fields `timestamp`, `state`, and a list containing all `sensor values`.
+The processor creates a new event containing:
+* A timestamp field
+* A list of buffered values
+* A list of states
+
+### Example
+
+#### Input Event
+```json
+{
+  "deviceId": "sensor01",
+  "timestamp": 1586380104915,
+  "state": ["active"],
+  "temperature": 23.5
+}
+```
+
+#### Configuration
+* Timestamp: timestamp
+* State: state
+* Sensor Value to Cache: temperature
+
+#### Output Event (when state changes from "active" to "inactive")
+```json
+{
+  "timestamp": 1586380105915,
+  "values": [23.5, 24.1, 24.3],
+  "state": ["active"]
+}
+```
+
+## Use Cases
+
+1. **State Monitoring**
+   * Cache sensor values
+   * Track state changes
+   * Monitor conditions
+   * Store measurements
+
+2. **Data Analysis**
+   * Analyze state patterns
+   * Track value changes
+   * Monitor conditions
+   * Store measurements
+
+## Notes
+
+* Values are cached during active states
+* Timestamps are preserved
+* State changes trigger updates
+* Processing is stateful
+* Multiple values can be buffered
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.state.labeler.buffer/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.state.labeler.buffer/documentation.md
index 4b73d3e7b8..a39fd749a5 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.state.labeler.buffer/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.state.labeler.buffer/documentation.md
@@ -26,40 +26,114 @@
 
 ## Description
 
-Apply a rule to a time-series recorded during a state of a machine.
-(E.g. when minimum value is lower then 10, add label `not ok` else add label `ok`)
-
+The State Buffer Labeler processor adds labels to sensor time-series data based on statistical operations and user-defined rules. It supports:
+* State-based labeling
+* Statistical operations (min, max, average)
+* Custom rule definition
+* Multiple conditions
+* Default labels
+
+This processor is essential for:
+* Adding context to data
+* Classifying measurements
+* Identifying patterns
+* Marking conditions
 
 ***
 
 ## Required input
 
-Requires a list with sensor values and a field defining the state
+The processor requires a data stream containing:
+* A state field (array of strings)
+* A sensor value field (array of numbers)
 
-### Sensor values
+***
 
-An array representing sensor values recorded during the state.
+## Configuration
 
-### State field
+### State Field
 
-A field representing the state when the sensor values where recorded.
+Select the field containing the state information. This determines when rules are applied.
 
-***
+### Select a specific state
 
-## Configuration
+Add a filter to define which states to evaluate. Use '*' to select all states.
 
-### Select a specific state
-When you are interested in the values of a specific state add it here.
-All other states will be ignored. To get results of all states enter `*`
+### Sensor values
+
+Select the array containing the sensor values to evaluate against the rules.
 
 ### Operation
-Operation that will be performed on the sensor values (calculate `maximim`, or `average`, or `minimum`)
+
+Define the statistical operation to apply to the sensor values:
+* Minimum: Get the lowest value
+* Maximum: Get the highest value
+* Average: Calculate the mean value
 
 ### Condition
-Define a rule which label to add. Example: `<;5;nok` means when the calculated value is smaller then 5 add label ok.
-The default label can be defined with `*;nok`.
-The first rule that is true defines the label. Rules are applied in the same order as defined here.
 
+Add conditions in the format:
+* `<;5;ok` - Label as "ok" if value is less than 5
+* `<;10;ok` - Label as "ok" if value is less than 10
+* `*;nok` - Default label "nok" for all other cases
 
 ## Output
-Appends a new field  with the label defined in the Condition Configuration
+
+The processor creates a new event containing:
+* All original fields from the input event
+* A new label field based on the conditions
+
+### Example
+
+#### Input Event
+```json
+{
+  "deviceId": "sensor01",
+  "timestamp": 1586380104915,
+  "state": ["active"],
+  "values": [23.5, 24.1, 24.3]
+}
+```
+
+#### Configuration
+* State Field: state
+* Select a specific state: active
+* Sensor values: values
+* Operation: Average
+* Condition: "<;20;cold", "<;30;warm", "*;hot"
+
+#### Output Event
+```json
+{
+  "deviceId": "sensor01",
+  "timestamp": 1586380104915,
+  "state": ["active"],
+  "values": [23.5, 24.1, 24.3],
+  "label": "warm"
+}
+```
+
+## Use Cases
+
+1. **Data Classification**
+   * Add context to data
+   * Classify measurements
+   * Identify patterns
+   * Mark conditions
+
+2. **Quality Control**
+   * Label quality levels
+   * Mark thresholds
+   * Identify issues
+   * Track conditions
+
+## Notes
+
+* Conditions are evaluated in order
+* Default label is required
+* State filtering is optional
+* Processing is stateless
+* Multiple conditions supported
+* Statistical operation is applied before condition evaluation
+* Input arrays must contain numeric values
+* State field must be an array of strings
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.state.labeler.number/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.state.labeler.number/documentation.md
index 8c34b55db3..2a9d78435a 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.state.labeler.number/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.state.labeler.number/documentation.md
@@ -26,27 +26,95 @@
 
 ## Description
 
-Apply a rule to a value of a field. (E.g. when minimum value is lower then 10, add label `not ok` else add label `ok`)
+The Number Labeler processor adds labels to numerical values based on user-defined rules. It supports:
+* Value-based labeling
+* Custom rule definition
+* Multiple conditions
+* Default labels
+* Value comparison
+
+This processor is essential for:
+* Classifying measurements
+* Adding context to data
+* Identifying patterns
+* Marking conditions
 
 ***
 
 ## Required input
 
-Requires a sensor value
-
-### Sensor value
-
-A number representing the current sensor value.
+The processor requires a data stream containing:
+* A numerical value field to evaluate
+* Timestamp information
 
 ***
 
 ## Configuration
 
+### Sensor Value
+
+Select the numerical field to evaluate against the rules.
+
+### Label Name
+
+Specify the name of the label field in the output event.
+
 ### Condition
-Define a rule which label to add. Example: `<;5;nok` means when the calculated value is smaller then 5 add label ok.
-The default label can be defined with `*;nok`.
-The first rule that is true defines the label. Rules are applied in the same order as defined here.
 
+Add conditions in the format:
+* `<;5;low` - Label as "low" if value is less than 5
+* `<;10;medium` - Label as "medium" if value is less than 10
+* `*;high` - Default label "high" for all other cases
 
 ## Output
-Appends a new field  with the label defined in the Condition Configuration
+
+The processor creates a new event containing:
+* All original fields from the input event
+* A new label field based on the conditions
+
+### Example
+
+#### Input Event
+```json
+{
+  "deviceId": "sensor01",
+  "timestamp": 1586380104915,
+  "temperature": 23.5
+}
+```
+
+#### Configuration
+* Sensor Value: temperature
+* Label Name: temperature_status
+* Condition: "<;20;cold", "<;30;warm", "*;hot"
+
+#### Output Event
+```json
+{
+  "deviceId": "sensor01",
+  "timestamp": 1586380104915,
+  "temperature": 23.5,
+  "temperature_status": "warm"
+}
+```
+
+## Use Cases
+
+1. **Data Classification**
+   * Classify measurements
+   * Add context to data
+   * Identify patterns
+   * Mark conditions
+
+2. **Quality Control**
+   * Label quality levels
+   * Mark thresholds
+   * Identify issues
+   * Track conditions
+
+## Notes
+
+* Conditions are evaluated in order
+* Default label is required
+* Processing is stateless
+* Multiple conditions supported
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.staticmetadata/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.staticmetadata/documentation.md
index ebfc4a7092..9c687c7863 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.staticmetadata/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.staticmetadata/documentation.md
@@ -17,52 +17,121 @@
   -->
 ## Static Metadata Enricher
 
-Enrich a data stream by dynamically adding fields based on user-provided static metadata configuration.
+<p align="center">
+    <img src="icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
 
----
+***
 
 ## Description
 
-The Static Metadata Enricher is designed to enrich a data stream by dynamically adding fields based on user-provided
-metadata configuration. Users can specify static properties, and the processor will process each event, adding fields
-according to the provided key-value pairs. The output strategy is determined dynamically based on the provided metadata.
-For added convenience, users also have the option of uploading a CSV file with metadata information.
+The Static Metadata Enricher processor adds predefined metadata fields to events. It supports:
+* Custom field addition
+* Multiple data types (String, Boolean, Float, Integer)
+* Field labeling
+* Field descriptions
+* Runtime naming
+* Metadata enrichment
 
-### Configuration
+This processor is essential for:
+* Adding context to data
+* Enriching events
+* Creating metadata
+* Building annotations
+* Standardizing fields
+* Documenting data
 
-For each metadata entry, configure the following three options:
+***
 
-- **Runtime Name:** A unique identifier for the property during runtime.
-- **Value:** The value associated with the property.
-- **Data Type:** The data type of the property value.
+## Required input
 
-#### Using CSV Option
+The processor requires a data stream to enrich with additional metadata fields.
 
-Alternatively, you can utilize the CSV upload feature by creating a CSV file with the following format:
+***
 
-```
-Runtime Name,Runtime Value,Data Type
-sensorType,Temperature,String
-maxSensorValue,100.0,Float
-minSensorValue,0,Float
-```
+## Configuration
+
+### Metadata Input
+
+Configure the metadata fields to add to each event:
+
+#### Runtime Name
+Enter the name that will be used for the field in the output event.
+
+#### Runtime Value
+Enter the value that will be assigned to the field.
+
+#### Data Type
+Select the data type of the value:
+* String: Text values
+* Boolean: true/false values
+* Float: Decimal numbers
+* Integer: Whole numbers
+
+#### Label (Optional)
+Provide a short label describing the field.
 
-## Example
-### Input Event
+#### Description (Optional)
+Provide a detailed description of the field.
 
+## Output
+
+The processor creates a new event containing:
+* All original fields from the input event
+* The configured metadata fields with their values
+
+### Example
+
+#### Input Event
 ```json
 {
-  "reading": 25.5
+  "deviceId": "sensor01",
+  "temperature": 23.5,
+  "humidity": 45.2
 }
 ```
 
-### Output Event
+#### Configuration
+* Runtime Name: location
+* Runtime Value: Building A
+* Data Type: String
+* Label: Sensor Location
+* Description: Physical location of the sensor
 
+#### Output Event
 ```json
 {
-  "reading": 25.5,
-  "sensorType": "Temperature",
-  "maxSensorValue": 100.0,
-  "minSensorValue": 0.0
+  "deviceId": "sensor01",
+  "temperature": 23.5,
+  "humidity": 45.2,
+  "location": "Building A"
 }
 ```
+
+## Use Cases
+
+1. **Data Enrichment**
+   * Add context to data
+   * Enrich events
+   * Create metadata
+   * Build annotations
+   * Standardize fields
+
+2. **Documentation**
+   * Document data
+   * Add descriptions
+   * Create labels
+   * Build metadata
+   * Standardize fields
+
+## Notes
+
+* Multiple fields can be added
+* Data types must match values
+* Labels are optional
+* Descriptions are optional
+* Processing is stateless
+* Field names must be unique
+* Values are automatically cast to the selected data type
+* Original event fields are preserved
+* Metadata is consistent across all events
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.stringoperator.state/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.stringoperator.state/documentation.md
index c58304e58b..f38402ab5e 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.stringoperator.state/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.stringoperator.state/documentation.md
@@ -26,20 +26,81 @@
 
 ## Description
 
-Convert string fields to a state representing the current state of the system.
-This processor requires one or multiple string values in the data stream.
-For each of the selected values is added to the states field.
+The String To State processor transforms string properties into a list of state values. It supports:
+* Multiple string inputs
+* List-based state output
+* Field value preservation
+* State collection
+
+This processor is essential for:
+* Converting strings to states
+* Collecting multiple states
+* Preserving field values
+* Creating state lists
+
 ***
 
 ## Required input
 
-### String Fields
-String fields that are added to the state array
+The processor requires a data stream containing at least one string field to convert into a state.
 
 ***
 
 ## Configuration
-No further configuration required
+
+### State Field
+
+Select one or more string fields to convert into states. The values of these fields will be collected into a list of states.
 
 ## Output
-The output contains a new value with the string values of the state
+
+The processor creates a new event containing:
+* All original fields from the input event
+* A new field named "current_state" containing a list of the selected string field values
+
+### Example
+
+#### Input Event
+```json
+{
+  "deviceId": "sensor01",
+  "status": "running",
+  "mode": "normal"
+}
+```
+
+#### Configuration
+* State Fields: status, mode
+
+#### Output Event
+```json
+{
+  "deviceId": "sensor01",
+  "status": "running",
+  "mode": "normal",
+  "current_state": ["running", "normal"]
+}
+```
+
+## Use Cases
+
+1. **State Collection**
+   * Gather multiple states
+   * Track field values
+   * Monitor statuses
+   * Collect modes
+
+2. **State Analysis**
+   * Analyze state combinations
+   * Track value patterns
+   * Monitor field changes
+   * Process state lists
+
+## Notes
+
+* Multiple fields can be selected
+* Output is always a list
+* Original fields are preserved
+* Processing is stateless
+* Empty selections result in empty list
+* Field values are preserved as-is
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.timestampextractor/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.timestampextractor/documentation.md
index c3e64d8684..0331d4e3a9 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.timestampextractor/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.processor.timestampextractor/documentation.md
@@ -26,14 +26,30 @@
 
 ## Description
 
-This processor extracts a timestamp into the individual time fields (e.g. day field, hour field, ....)
+The Timestamp Extractor processor breaks down a timestamp into its individual time components. It supports:
+* Year extraction
+* Month extraction
+* Day extraction
+* Hour extraction
+* Minute extraction
+* Second extraction
+* Weekday extraction
+* Custom field selection
+* Component isolation
+
+This processor is essential for:
+* Time analysis
+* Date processing
+* Time component extraction
+* Temporal analysis
+* Time-based grouping
+* Time series analysis
 
 ***
 
 ## Required input
 
-This processor requires an event that provides a timestamp value (a field that is marked to be of type ``http://schema
-.org/DateTime``.
+The processor requires a data stream containing at least one timestamp field to extract components from.
 
 ***
 
@@ -41,12 +57,96 @@ This processor requires an event that provides a timestamp value (a field that i
 
 ### Timestamp Field
 
-The field of the event containing the timestamp to parse.
+Select the field containing the timestamp to extract components from. This should be a valid timestamp value.
 
 ### Extract Fields
 
-Select the individual parts of the timestamp that should be extracted, e.g., Year, Minute and Day.
+Select which time components to extract:
+* Year (numeric)
+* Month (numeric, 1-12)
+* Day (numeric, 1-31)
+* Hour (numeric, 0-23)
+* Minute (numeric, 0-59)
+* Second (numeric, 0-59)
+* Weekday (string: Monday-Sunday)
 
 ## Output
 
-The output of this processor is a new event that contains the fields selected by the ``Extract Fields`` parameter.
\ No newline at end of file
+The processor creates a new event containing:
+* All original fields from the input event
+* New fields for each extracted time component with prefix "timestamp"
+* Original timestamp preserved
+
+### Example
+
+#### Input Event
+```json
+{
+  "deviceId": "sensor01",
+  "timestamp": 1586380104915,
+  "value": 23.5
+}
+```
+
+#### Configuration
+* Timestamp Field: timestamp
+* Extract Fields: year, month, day, hour, minute, weekday
+
+#### Output Event
+```json
+{
+  "deviceId": "sensor01",
+  "timestamp": 1586380104915,
+  "value": 23.5,
+  "timestampYear": 2020,
+  "timestampMonth": 4,
+  "timestampDay": 8,
+  "timestampHour": 15,
+  "timestampMinute": 35,
+  "timestampWeekday": "Wednesday"
+}
+```
+
+## Use Cases
+
+1. **Time Analysis**
+   * Extract time components
+   * Analyze patterns
+   * Group by time
+   * Track changes
+   * Build time series
+
+2. **Data Processing**
+   * Process timestamps
+   * Extract components
+   * Analyze patterns
+   * Group data
+   * Build metrics
+
+3. **Reporting**
+   * Generate time reports
+   * Extract components
+   * Analyze patterns
+   * Group data
+   * Build summaries
+
+4. **Monitoring**
+   * Monitor time patterns
+   * Extract components
+   * Analyze trends
+   * Track changes
+   * Build alerts
+
+## Notes
+
+* Timestamp must be valid
+* Components are optional
+* Processing is stateless
+* Multiple components supported
+* Extraction is immediate
+* No delay in processing
+* Original timestamp preserved
+* Components are standardized
+* Weekday is returned as string
+* Month is 1-based (1-12)
+* Hour is 24-hour format (0-23)
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.round/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.round/documentation.md
index 90f67db771..c8b05a51cc 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.round/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.round/documentation.md
@@ -26,14 +26,18 @@
 
 ## Description
 
-This processor rounds numeric values to the given decimal places.
-It supports multiple rounding strategies.
+The Number Rounder processor provides precise control over the decimal places in numerical data by applying various rounding strategies. This is essential for:
+* Ensuring consistent precision across numerical data
+* Reducing noise in measurements
+* Improving data readability
+* Meeting specific business or technical requirements for numerical precision
+* Standardizing numerical outputs for downstream processing
 
 ***
 
 ## Required input
 
-This processor requires an event that provides numerical properties.
+This processor requires an event that contains one or more numerical properties (integers or floating-point numbers).
 
 ***
 
@@ -41,26 +45,95 @@ This processor requires an event that provides numerical properties.
 
 ### Fields to Be Rounded
 
-Select which fields of the event should be rounded.
+Select which numerical fields in the event should be rounded. Multiple fields can be selected, and each will be rounded according to the same configuration.
 
 ### Number of Digits
 
-Specify the number of digits after the decimal point to round/keep, e.g., if number is 2.8935 and 'digits' is 3,
-the result will be 2.894.
+Specify the number of decimal places to keep after rounding. This determines the precision of the output:
+* Positive values (e.g., 2): Keep that many decimal places
+* Zero (0): Round to whole numbers
+* Negative values (e.g., -2): Round to tens, hundreds, etc.
+
+Examples:
+* Input: 2.8935, Digits: 3 → Output: 2.894
+* Input: 2.8935, Digits: 2 → Output: 2.89
+* Input: 2.8935, Digits: 0 → Output: 3
+* Input: 285.8935, Digits: -2 → Output: 300
 
 ### Mode of Rounding
 
-Specify the mode of rounding. 
-Supported rounding modes:
-* `UP`: Rounding mode to round away from zero. Always increments the digit prior to a non-zero discarded fraction. Note that this rounding mode never decreases the magnitude of the calculated value.
-* `DOWN`: Rounding mode to round towards zero. Never increments the digit prior to a discarded fraction (i.e., truncates). Note that this rounding mode never increases the magnitude of the calculated value.
-* `CEILING`: Rounding mode to round towards positive infinity. If the result is positive, behaves as for `UP`; if negative, behaves as for `DOWN`. Note that this rounding mode never decreases the calculated value
-* `FLOOR`: Rounding mode to round towards negative infinity. If the result is positive, behave as for `DOWN`; if negative, behave as for `UP`. Note that this rounding mode never increases the calculated value.
-* `HALF_UP`: Rounding mode to round towards "nearest neighbor" unless both neighbors are equidistant, in which case round up. Behaves as for `UP` if the discarded fraction is ≥ 0.5; otherwise, behaves as for `DOWN`.
-* `HALF_DOWN`: Rounding mode to round towards "nearest neighbor" unless both neighbors are equidistant, in which case round down. Behaves as for `UP` if the discarded fraction is > 0.5; otherwise, behaves as for `DOWN`.
-* `HALF_EVEN`: Rounding mode to round towards the "nearest neighbor" unless both neighbors are equidistant, in which case, round towards the even neighbor. Behaves as for `HALF_UP` if the digit to the left of the discarded fraction is odd; behaves as for `HALF_DOWN` if it's even. Note that this is the rounding mode that statistically minimizes cumulative error when applied repeatedly over a sequence of calculations.
+Select the rounding strategy to use. Each mode handles rounding differently, especially around the midpoint between two numbers:
+
+* **UP** 
+  * Always rounds away from zero
+  * 3.1 → 4, -3.1 → -4
+  * Use when you need to ensure the result is never smaller in magnitude
+
+* **DOWN**
+  * Always rounds toward zero (truncates)
+  * 3.7 → 3, -3.7 → -3
+  * Use when you need to ensure the result is never larger in magnitude
+
+* **CEILING**
+  * Always rounds toward positive infinity
+  * 3.1 → 4, -3.7 → -3
+  * Use when you need to ensure the result never decreases
+
+* **FLOOR**
+  * Always rounds toward negative infinity
+  * 3.7 → 3, -3.1 → -4
+  * Use when you need to ensure the result never increases
+
+* **HALF_UP** (Most common)
+  * Rounds to nearest number, ties round up
+  * 3.5 → 4, 3.4 → 3, -3.5 → -4
+  * Use for standard mathematical rounding
+
+* **HALF_DOWN**
+  * Rounds to nearest number, ties round down
+  * 3.5 → 3, 3.6 → 4, -3.5 → -3
+  * Use when ties should be rounded down
+
+* **HALF_EVEN** (Banker's Rounding)
+  * Rounds to nearest number, ties round to even neighbor
+  * 3.5 → 4, 4.5 → 4, -3.5 → -4
+  * Use to minimize cumulative rounding errors in large datasets
 
 ## Output
 
-The output of this processor is the same event with the fields selected by the ``Fiels to Be Rounded`` parameter rounded
-to ``Number of Digits`` digits.
\ No newline at end of file
+The processor outputs an event with the same structure as the input, but with the selected numerical fields rounded according to the configuration. All other fields remain unchanged.
+
+### Example
+
+#### Input Event
+```json
+{
+  "sensorId": "temp01",
+  "temperature": 23.4567,
+  "pressure": 1013.8935,
+  "humidity": 45.5000
+}
+```
+
+#### Configuration
+* Fields to Be Rounded: temperature, pressure
+* Number of Digits: 2
+* Mode of Rounding: HALF_UP
+
+#### Output Event
+```json
+{
+  "sensorId": "temp01",
+  "temperature": 23.46,
+  "pressure": 1013.89,
+  "humidity": 45.5000
+}
+```
+
+## Use Cases
+
+1. **Measurement Data**: Standardize precision of sensor readings
+2. **Financial Calculations**: Ensure proper decimal handling in monetary values
+3. **Scientific Analysis**: Control significant figures in experimental data
+4. **Display Formatting**: Prepare numbers for user interfaces
+5. **Data Storage**: Optimize numerical precision for storage efficiency
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.split-array/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.split-array/documentation.md
index 665c6092b9..5af7643708 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.split-array/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.split-array/documentation.md
@@ -26,29 +26,117 @@
 
 ## Description
 
-This processor takes an array of event properties and creates an event for each of them.
-Further property of the events can be added to each element.
+The Split Array processor transforms array fields into multiple individual events, with each array element becoming a separate event. It supports:
+* Array element extraction
+* Context preservation
+* Nested field handling
+* Custom field naming
+
+This processor is essential for:
+* Converting batch data into individual events
+* Processing array elements independently
+* Distributing array data across streams
+* Enabling element-wise analysis
 
 ***
 
 ## Required input
 
-This processor works with any event that has a field of type ``list``.
+The processor requires a data stream containing at least one array field. The array can contain elements of any supported data type:
+* Numbers (integer or float)
+* Strings
+* Booleans
+* Objects
+* Nested arrays
 
 ***
 
 ## Configuration
 
-### Keep Fields
-
-Fields of the event that should be kept in each resulting event.
+### Array Field Selection
 
-### List field
+Select the array field to split into individual events. The field must be an array type.
 
-The name of the field that contains the list values that should be split.
+### Keep Fields
 
+Select one or more fields from the input event that should be preserved in each output event. These fields will be copied to each output event.
 
 ## Output
 
-This data processor produces an event with all fields selected by the ``Keep Fields`` parameter and all fields of the
- selected list field.
\ No newline at end of file
+For each element in the input array, the processor creates a new event containing:
+* The array element as a single value in a field named "array_value"
+* All selected fields from the original event
+
+### Example
+
+#### Input Event
+```json
+{
+  "deviceId": "sensor123",
+  "timestamp": 1586380104915,
+  "measurements": [22.5, 23.1, 22.8, 23.4],
+  "status": "active"
+}
+```
+
+#### Configuration
+* Array Field: measurements
+* Keep Fields: deviceId, timestamp, status
+
+#### Output Events
+```json
+// First element
+{
+  "deviceId": "sensor123",
+  "timestamp": 1586380104915,
+  "status": "active",
+  "array_value": 22.5
+}
+
+// Second element
+{
+  "deviceId": "sensor123",
+  "timestamp": 1586380104915,
+  "status": "active",
+  "array_value": 23.1
+}
+
+// Third element
+{
+  "deviceId": "sensor123",
+  "timestamp": 1586380104915,
+  "status": "active",
+  "array_value": 22.8
+}
+
+// Fourth element
+{
+  "deviceId": "sensor123",
+  "timestamp": 1586380104915,
+  "status": "active",
+  "array_value": 23.4
+}
+```
+
+## Use Cases
+
+1. **Batch Processing**
+   * Split batch sensor readings
+   * Process multi-measurement data
+   * Handle grouped observations
+   * Transform batch uploads
+
+2. **Data Distribution**
+   * Distribute workload across processors
+   * Enable parallel processing
+   * Balance processing load
+   * Scale data processing
+
+## Notes
+
+* Output events maintain original event order
+* Empty arrays produce no output events
+* Null array elements are preserved
+* Processing is stateless
+* Memory usage scales with array size
+* Nested fields are handled automatically
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.stringoperator.counter/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.stringoperator.counter/documentation.md
index 57c778cb89..a8e9d8f411 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.stringoperator.counter/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.stringoperator.counter/documentation.md
@@ -26,34 +26,107 @@
 
 ## Description
 
-This processor monitors a string field and counts how often the value of the string changes.
-Hereby, a change is characterized by
-the value of the field before and the value after the change, combined forming a pair.
-The processor keeps track of the counter for each pair.
+The String Counter processor counts changes in string field values. It supports:
+* Value change detection
+* Change pair tracking
+* Incremental counting
+* State transition monitoring
+
+This processor is essential for:
+* Counting value changes
+* Tracking state transitions
+* Monitoring string patterns
+* Measuring change frequency
 
 ***
 
 ## Required input
 
-A string field is required in the data stream and can be selected with the field mapping.
-
-### String Field
-
-The string field to be monitored.
+The processor requires a data stream containing at least one string field to monitor for value changes.
 
 ***
 
 ## Configuration
 
-(no further configuration required)
-
-## Output
+### String Field
 
-The following three fields are appended to the event:
+Select the string field to monitor for value changes. This field will be used to detect changes and increment the counter.
 
-* [counter] numerical field with the current count value for the given value pair
-* [change_from] the value of the string before the change
-* [change_to] the value of the string after the change
+## Output
 
-The event is emitted whenever the value of the string field changes.
+The processor creates a new event containing:
+* All original fields from the input event
+* A new field named "counter" containing the current count of value changes
+* A new field named "change_from" containing the previous value
+* A new field named "change_to" containing the new value
+
+### Example
+
+#### Input Event Stream
+```json
+{
+  "deviceId": "sensor01",
+  "status": "idle"
+}
+```
+```json
+{
+  "deviceId": "sensor01",
+  "status": "running"
+}
+```
+```json
+{
+  "deviceId": "sensor01",
+  "status": "idle"
+}
+```
+
+#### Configuration
+* String Field: status
+
+#### Output Event
+```json
+{
+  "deviceId": "sensor01",
+  "status": "running",
+  "change_from": "idle",
+  "change_to": "running",
+  "counter": 1
+}
+```
+```json
+{
+  "deviceId": "sensor01",
+  "status": "idle",
+  "change_from": "running",
+  "change_to": "idle",
+  "counter": 2
+}
+```
+
+## Use Cases
+
+1. **State Monitoring**
+   * Track state changes
+   * Count transitions
+   * Monitor patterns
+   * Measure frequency
+
+2. **Process Analysis**
+   * Analyze workflows
+   * Track sequences
+   * Count cycles
+   * Monitor operations
+
+## Notes
+
+* Only counts actual value changes
+* Ignores consecutive identical values
+* Processing is stateful
+* Counter is incremental
+* Events are only emitted on value changes
+* Original event fields are preserved
+* Change pairs are tracked (from -> to)
+* Counter starts at 1 for first change
 
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.stringoperator.timer/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.stringoperator.timer/documentation.md
index c6dd5a08ae..60c3d367ea 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.stringoperator.timer/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.stringoperator.timer/documentation.md
@@ -26,35 +26,98 @@
 
 ## Description
 
-This processor measures how long a value of a string field does not change.
-Once the value is changes the event with the measured time and the corresponding string value is emitted.
-
+The String Timer processor measures how long a string field maintains a specific value. It supports:
+* String value monitoring
+* Duration measurement
+* Multiple time units
+* Configurable output frequency
+
+This processor is essential for:
+* Measuring state durations
+* Tracking value persistence
+* Monitoring string states
+* Calculating time periods
 
 ***
 
 ## Required input
 
-A string field is required in the data stream.
+The processor requires a data stream containing at least one string field to monitor for value changes.
 
-### Field
+***
 
-The string field which is monitored for any value changes.
+## Configuration
 
+### String Field
 
-***
+Select the string field to monitor for value changes. This field will be used to measure how long it maintains a specific value.
 
-## Configuration
+### Output Unit
+
+Choose the time unit for the measured duration:
+* Milliseconds (default)
+* Seconds
+* Minutes
 
 ### Output Frequency
 
-Define when an event should be emitted, either on each input event or just when the string value changes.
+Define when the processor should emit an output event:
+* On Input Event: Emit for every input event
+* When String Value Changes: Emit only when the string value changes
 
 ## Output
 
-The following two fields are appended to the event:
-
-* [measured_time] the measured time for the string value to not change
-* [field_value] the corresponding string value
-
-The event is emitted whenever the value of the string field changes.
+The processor creates a new event containing:
+* All original fields from the input event
+* A measured_time field showing the duration in the selected unit
+* A field_value field showing the previous string value
+
+### Example
+
+#### Input Event
+```json
+{
+  "deviceId": "machine01",
+  "status": "running",
+  "timestamp": 1586380104915
+}
+```
+
+#### Configuration
+* String Field: status
+* Output Unit: Seconds
+* Output Frequency: When String Value Changes
+
+#### Output Event (when status changes from "running" to "stopped")
+```json
+{
+  "deviceId": "machine01",
+  "status": "stopped",
+  "timestamp": 1586380106915,
+  "measured_time": 2.0,
+  "field_value": "running"
+}
+```
+
+## Use Cases
+
+1. **State Monitoring**
+   * Measure state durations
+   * Track value persistence
+   * Monitor status changes
+   * Calculate time periods
+
+2. **Process Control**
+   * Measure process durations
+   * Track state changes
+   * Monitor operations
+   * Calculate times
+
+## Notes
+
+* Only string fields can be monitored
+* Time measurement is stateful
+* Measurement starts on value change
+* Measurement ends on next change
+* Output depends on frequency setting
 
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.taskduration/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.taskduration/documentation.md
index 5cbe48e563..9e262e1693 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.taskduration/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.taskduration/documentation.md
@@ -18,27 +18,123 @@
 
 ## Task Duration
 
+<p align="center">
+    <img src="icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
 
 ***
 
 ## Description
 
-This processors computes the duration of a task, i.e., a field containing a task description. It outputs an event
- every time this task value changes and computes the duration between the first occurrence of this task and the
-  current event. For instance, you can use this event to calculate the time a specific process step requires.
+The Task Duration processor calculates the time duration between state changes in a task field. It supports:
+* Task state tracking
+* Duration calculation
+* Multiple time units
+* Process identification
+* State transition timing
+* Performance measurement
+
+This processor is essential for:
+* Measuring task durations
+* Tracking process times
+* Analyzing state transitions
+* Monitoring performance
+* Building metrics
+* Optimizing workflows
+
 ***
 
 ## Required input
 
-A timestamp value is required and a field containing a task value.
+The processor requires a data stream containing:
+* A task field that changes to indicate different states
+* A timestamp field for duration calculation
 
 ***
 
 ## Configuration
 
-(no further configuration required)
+### Task Field
+Select the field that contains the task state. The processor will calculate the duration between changes in this field.
+
+### Timestamp Field
+Select the field containing the timestamp for duration calculation.
+
+### Output Unit
+Choose the time unit for the duration output:
+* Milliseconds (default)
+* Seconds
+* Minutes
 
 ## Output
 
-Emits an event that contains the process step, built from the names of the first task identifier and the identifier
- of the subsequent task. In addition, the duration is part of the output event, provided in milliseconds.
\ No newline at end of file
+The processor creates a new event containing:
+* A processId field showing the state transition (format: "previousState-newState")
+* A duration field showing the time between state changes in the selected unit
+
+### Example
+
+#### Input Event
+```json
+{
+  "deviceId": "machine01",
+  "timestamp": 1586380104915,
+  "taskState": "running"
+}
+```
+
+#### Configuration
+* Task Field: taskState
+* Timestamp Field: timestamp
+* Output Unit: Seconds
+
+#### Output Event (when taskState changes from "running" to "completed")
+```json
+{
+  "processId": "running-completed",
+  "duration": 120.5
+}
+```
+
+## Use Cases
+
+1. **Process Timing**
+   * Measure task durations
+   * Track state transitions
+   * Analyze process times
+   * Monitor performance
+   * Build metrics
+
+2. **Workflow Analysis**
+   * Measure step durations
+   * Track transitions
+   * Analyze workflows
+   * Monitor efficiency
+   * Build analytics
+
+3. **Performance Monitoring**
+   * Measure state durations
+   * Track changes
+   * Analyze timing
+   * Monitor efficiency
+   * Build reports
+
+4. **Quality Control**
+   * Measure cycle times
+   * Track states
+   * Analyze durations
+   * Monitor quality
+   * Build controls
+
+## Notes
+
+* Task field must change to trigger output
+* Duration is calculated between state changes
+* Multiple time units supported
+* Processing is stateful
+* ProcessId shows state transition
+* Consider time unit selection
+* No delay in processing
+* Original values not preserved
+* Only outputs on state change
+* Duration is always positive
\ No newline at end of file
diff --git a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.transform-to-boolean/documentation.md b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.transform-to-boolean/documentation.md
index a889be6ce5..81d698bbce 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.transform-to-boolean/documentation.md
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.transform-to-boolean/documentation.md
@@ -26,22 +26,83 @@
 
 ## Description
 
-This processors transforms numbers and strings to boolean values.
+The Transform to Boolean processor converts string or number fields into boolean values. It supports:
+* String to boolean conversion
+* Number to boolean conversion
+* Multiple field transformation
+* In-place value modification
 
+This processor is essential for:
+* Converting data types
+* Creating boolean flags
+* Transforming values
+* Standardizing data
 
 ***
 
 ## Required input
 
-A string with the values "true", "True", "false", "False" or a number with value 1.0, 1, 0, or 0.0
+The processor requires a data stream containing at least one string or number field to transform into a boolean.
 
 ***
 
 ## Configuration
 
-Select fields that should be converted to boolean.
+### Transform Fields
+
+Select one or more string or number fields to transform into boolean values. The transformation rules are:
+* Strings: "true" or "1" becomes true, "false" or "0" becomes false
+* Numbers: 1 or 1.0 becomes true, 0 or 0.0 becomes false
 
 ## Output
 
-Selected properties of input events are transformed to booleans.
-When the value is not valid an error message is logged and the event is discarde.
\ No newline at end of file
+The processor creates a new event containing:
+* All original fields from the input event
+* The selected fields with their values transformed to boolean
+
+### Example
+
+#### Input Event
+```json
+{
+  "deviceId": "sensor01",
+  "status": "true",
+  "value": 1,
+  "timestamp": 1586380104915
+}
+```
+
+#### Configuration
+* Transform Fields: status, value
+
+#### Output Event
+```json
+{
+  "deviceId": "sensor01",
+  "status": true,
+  "value": true,
+  "timestamp": 1586380104915
+}
+```
+
+## Use Cases
+
+1. **Data Standardization**
+   * Convert string states
+   * Transform numeric flags
+   * Standardize values
+   * Create boolean flags
+
+2. **Condition Creation**
+   * Create boolean conditions
+   * Transform thresholds
+   * Convert states
+   * Build flags
+
+## Notes
+
+* Only string and number fields can be transformed
+* String comparison is case-insensitive
+* Numbers use 1/0 logic
+* Processing is stateless
+* Multiple fields can be transformed
\ No newline at end of file