From 07b869c291a59ffe921a70b284709c72cd33237f Mon Sep 17 00:00:00 2001
From: Stefaan Lippens <stefaan.lippens@vito.be>
Date: Tue, 14 Mar 2023 21:28:04 +0100
Subject: [PATCH] Issue #390 add ProcessBuilder and `openeo.processes` docs

---
 CHANGELOG.md                           |   2 +
 docs/_static/custom.css                |   4 +
 docs/api-processbuilder.rst            |  87 +++++++
 docs/api-processes.rst                 |  69 ++++++
 docs/api.rst                           |   6 +-
 docs/index.rst                         |   1 +
 docs/process_mapping.py                |   9 +
 docs/process_mapping.rst               | 296 ++++++++++++++++++-----
 docs/processes.rst                     |  91 ++++---
 openeo/internal/processes/generator.py |  60 +++--
 openeo/processes.py                    | 315 +++++++++++++++++++++++++
 openeo/rest/datacube.py                | 127 +++++++---
 12 files changed, 931 insertions(+), 136 deletions(-)
 create mode 100644 docs/api-processbuilder.rst
 create mode 100644 docs/api-processes.rst

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5daf0eedb..925f7d3d7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -26,6 +26,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   ([#386](https://github.com/Open-EO/openeo-python-client/issues/386)).
   The (experimental) `fit_class_random_forest()` and `fit_regr_random_forest()` methods
   moved accordingly to the `VectorCube` class.
+- Improved documentation on `openeo.processes` and `ProcessBuilder`
+  ([#390](https://github.com/Open-EO/openeo-python-client/issues/390)).
 
 ### Removed
 
diff --git a/docs/_static/custom.css b/docs/_static/custom.css
index 7c6b1977c..a05ac6839 100644
--- a/docs/_static/custom.css
+++ b/docs/_static/custom.css
@@ -104,3 +104,7 @@ pre {
     font-size: 75%;
     padding: 0 1ex;
 }
+
+nav.contents.local {
+    border: none;
+}
diff --git a/docs/api-processbuilder.rst b/docs/api-processbuilder.rst
new file mode 100644
index 000000000..7ebdca75c
--- /dev/null
+++ b/docs/api-processbuilder.rst
@@ -0,0 +1,87 @@
+..  FYI this file is intended to be inlined (with "include" RST directive)
+    in the ProcessBuilder class doc block,
+    which in turn is covered with autodoc/automodule from api-processes.rst.
+
+
+The :py:class:`ProcessBuilder <openeo.processes.ProcessBuilder>` class
+is a helper class that implements
+(much like the :ref:`openEO process functions <openeo_processes_functions>`)
+each openEO process as a method.
+On top of that it also adds syntactic sugar to support Python operators as well
+(e.g. ``+`` is translated to the ``add`` process).
+
+.. attention::
+    As normal user, you should never create a
+    :py:class:`ProcessBuilder <openeo.processes.ProcessBuilder>` instance
+    directly.
+
+    You should only interact with this class inside a callback
+    function/lambda while building a child callback process graph
+    as discussed at :ref:`child_callback_callable`.
+
+
+For example, let's start from this simple usage snippet
+where we want to reduce the temporal dimension
+by taking the temporal mean of each timeseries:
+
+.. code-block:: python
+
+    def my_reducer(data):
+        return data.mean()
+
+    cube.reduce_dimension(reducer=my_reducer, dimension="t")
+
+Note that this ``my_reducer`` function has a ``data`` argument,
+which conceptually corresponds to an array of pixel values
+(along the temporal dimension).
+However, it's important to understand that the ``my_reducer`` function
+is actually *not evaluated when you execute your process graph*
+on an openEO back-end, e.g. as a batch jobs.
+Instead, ``my_reducer`` is evaluated
+*while building your process graph client-side*
+(at the time you execute that ``cube.reduce_dimension()`` statement to be precise).
+This means that that ``data`` argument is actually not a concrete array of EO data,
+but some kind of *virtual placeholder*,
+a :py:class:`ProcessBuilder <openeo.processes.ProcessBuilder>` instance,
+that keeps track of the operations you intend to do on the EO data.
+
+To make that more concrete, it helps to add type hints
+which will make it easier to discover what you can do with the argument
+(depending on which editor or IDE you are using):
+
+.. code-block:: python
+
+    from openeo.processes import ProcessBuilder
+
+    def my_reducer(data: ProcessBuilder) -> ProcessBuilder:
+        return data.mean()
+
+    cube.reduce_dimension(reducer=my_reducer, dimension="t")
+
+
+Because :py:class:`ProcessBuilder <openeo.processes.ProcessBuilder>` methods
+return new :py:class:`ProcessBuilder <openeo.processes.ProcessBuilder>` instances,
+and because it support syntactic sugar to use Python operators on it,
+and because :ref:`openeo.process functions <openeo_processes_functions>`
+also accept and return :py:class:`ProcessBuilder <openeo.processes.ProcessBuilder>` instances,
+we can mix methods, functions and operators in the callback function like this:
+
+.. code-block:: python
+
+    from openeo.processes import ProcessBuilder, cos
+
+    def my_reducer(data: ProcessBuilder) -> ProcessBuilder:
+        return cos(data.mean()) + 1.23
+
+    cube.reduce_dimension(reducer=my_reducer, dimension="t")
+
+or compactly, using an anonymous lambda expression:
+
+.. code-block:: python
+
+    from openeo.processes import cos
+
+    cube.reduce_dimension(
+        reducer=lambda data: cos(data.mean())) + 1.23,
+        dimension="t"
+    )
diff --git a/docs/api-processes.rst b/docs/api-processes.rst
new file mode 100644
index 000000000..a27d876c4
--- /dev/null
+++ b/docs/api-processes.rst
@@ -0,0 +1,69 @@
+=========================
+API: ``openeo.processes``
+=========================
+
+The ``openeo.processes`` module contains building blocks and helpers
+to construct so called "child callbacks" for openEO processes like
+:py:meth:`openeo.rest.datacube.DataCube.apply` and
+:py:meth:`openeo.rest.datacube.DataCube.reduce_dimension`,
+as discussed at :ref:`child_callback_callable`.
+
+.. note::
+    The contents of the ``openeo.processes`` module is automatically compiled
+    from the official openEO process specifications.
+    Developers that want to fix bugs in, or add implementations to this
+    module should not touch the file directly, but instead address it in the
+    upstream `openeo-processes <https://github.com/Open-EO/openeo-processes>`_ repository
+    or in the internal tooling to generate this file.
+
+
+.. contents:: Sections:
+   :depth: 1
+   :local:
+   :backlinks: top
+
+
+.. _openeo_processes_functions:
+
+Functions in ``openeo.processes``
+---------------------------------
+
+The ``openeo.processes`` module implements (at top-level)
+a regular Python function for each openEO process
+(not only the official stable ones, but also experimental ones in "proposal" state).
+
+These functions can be used directly as child callback,
+for example as follows:
+
+.. code-block:: python
+
+    from openeo.processes import absolute, max
+
+    cube.apply(absolute)
+    cube.reduce_dimension(max, dimension="t")
+
+
+Note how the signatures of the parent :py:class:`DataCube <openeo.rest.datacube.DataCube>` methods
+and the callback functions match up:
+
+-   :py:meth:`DataCube.apply() <openeo.rest.datacube.DataCube.apply>`
+    expects a callback that receives a single numerical value,
+    which corresponds to the parameter signature of :py:func:`openeo.processes.absolute`
+-   :py:meth:`DataCube.reduce_dimension() <openeo.rest.datacube.DataCube.reduce_dimension>`
+    expects a callback that receives an array of numerical values,
+    which corresponds to the parameter signature :py:func:`openeo.processes.max`
+
+
+.. automodule:: openeo.processes
+    :members:
+    :exclude-members: ProcessBuilder, process, _process
+
+
+``ProcessBuilder`` helper class
+--------------------------------
+
+..  FYI the ProcessBuilder docs are provided through its doc block
+    with an RST "include" of "api-processbuilder.rst"
+
+.. automodule:: openeo.processes
+    :members: ProcessBuilder
diff --git a/docs/api.rst b/docs/api.rst
index e93fe3f3e..4198b43d7 100644
--- a/docs/api.rst
+++ b/docs/api.rst
@@ -1,6 +1,6 @@
-===
-API
-===
+=============
+API (General)
+=============
 
 High level Interface
 --------------------
diff --git a/docs/index.rst b/docs/index.rst
index 600e97351..b2c1ba643 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -60,6 +60,7 @@ Table of contents
    configuration
    cookbook/index
    api
+   api-processes
    process_mapping
    development
    best_practices
diff --git a/docs/process_mapping.py b/docs/process_mapping.py
index b5078193c..022ff50eb 100644
--- a/docs/process_mapping.py
+++ b/docs/process_mapping.py
@@ -9,6 +9,7 @@
 import datetime
 import sys
 from textwrap import dedent
+import importlib
 
 from openeo.internal.documentation import _process_registry
 
@@ -38,6 +39,14 @@ def main():
             *   - openEO process
                 - openEO Python Client Method
     """))
+    # Import some submodules to make sure `_process_registry` is populated
+    for mod in [
+        "openeo.rest.datacube",
+        "openeo.rest.vectorcube",
+        "openeo.rest.mlmodel",
+        "openeo.processes",
+    ]:
+        importlib.import_module(mod)
 
     for process_id in sorted(_process_registry.keys()):
         functions = [x[0] for x in _process_registry[process_id]]
diff --git a/docs/process_mapping.rst b/docs/process_mapping.rst
index f2d352450..f25eef6ad 100644
--- a/docs/process_mapping.rst
+++ b/docs/process_mapping.rst
@@ -18,129 +18,311 @@ method or function in the openEO Python Client Library.
     *   - openEO process
         - openEO Python Client Method
 
+    *   - `absolute <https://processes.openeo.org/#absolute>`_
+        - :py:meth:`ProcessBuilder.absolute() <openeo.processes.ProcessBuilder.absolute>`, :py:meth:`absolute() <openeo.processes.absolute>`
     *   - `add <https://processes.openeo.org/#add>`_
-        - :py:meth:`DataCube.add() <openeo.rest.datacube.DataCube.add>`, :py:meth:`DataCube.__add__() <openeo.rest.datacube.DataCube.__add__>`, :py:meth:`DataCube.__radd__() <openeo.rest.datacube.DataCube.__radd__>`
+        - :py:meth:`ProcessBuilder.__add__() <openeo.processes.ProcessBuilder.__add__>`, :py:meth:`ProcessBuilder.__radd__() <openeo.processes.ProcessBuilder.__radd__>`, :py:meth:`ProcessBuilder.add() <openeo.processes.ProcessBuilder.add>`, :py:meth:`add() <openeo.processes.add>`, :py:meth:`DataCube.add() <openeo.rest.datacube.DataCube.add>`, :py:meth:`DataCube.__add__() <openeo.rest.datacube.DataCube.__add__>`, :py:meth:`DataCube.__radd__() <openeo.rest.datacube.DataCube.__radd__>`
     *   - `add_dimension <https://processes.openeo.org/#add_dimension>`_
-        - :py:meth:`DataCube.add_dimension() <openeo.rest.datacube.DataCube.add_dimension>`
+        - :py:meth:`ProcessBuilder.add_dimension() <openeo.processes.ProcessBuilder.add_dimension>`, :py:meth:`add_dimension() <openeo.processes.add_dimension>`, :py:meth:`DataCube.add_dimension() <openeo.rest.datacube.DataCube.add_dimension>`
     *   - `aggregate_spatial <https://processes.openeo.org/#aggregate_spatial>`_
-        - :py:meth:`DataCube.aggregate_spatial() <openeo.rest.datacube.DataCube.aggregate_spatial>`
+        - :py:meth:`ProcessBuilder.aggregate_spatial() <openeo.processes.ProcessBuilder.aggregate_spatial>`, :py:meth:`aggregate_spatial() <openeo.processes.aggregate_spatial>`, :py:meth:`DataCube.aggregate_spatial() <openeo.rest.datacube.DataCube.aggregate_spatial>`
+    *   - `aggregate_spatial_window <https://processes.openeo.org/#aggregate_spatial_window>`_
+        - :py:meth:`ProcessBuilder.aggregate_spatial_window() <openeo.processes.ProcessBuilder.aggregate_spatial_window>`, :py:meth:`aggregate_spatial_window() <openeo.processes.aggregate_spatial_window>`
     *   - `aggregate_temporal <https://processes.openeo.org/#aggregate_temporal>`_
-        - :py:meth:`DataCube.aggregate_temporal() <openeo.rest.datacube.DataCube.aggregate_temporal>`
+        - :py:meth:`ProcessBuilder.aggregate_temporal() <openeo.processes.ProcessBuilder.aggregate_temporal>`, :py:meth:`aggregate_temporal() <openeo.processes.aggregate_temporal>`, :py:meth:`DataCube.aggregate_temporal() <openeo.rest.datacube.DataCube.aggregate_temporal>`
     *   - `aggregate_temporal_period <https://processes.openeo.org/#aggregate_temporal_period>`_
-        - :py:meth:`DataCube.aggregate_temporal_period() <openeo.rest.datacube.DataCube.aggregate_temporal_period>`
+        - :py:meth:`ProcessBuilder.aggregate_temporal_period() <openeo.processes.ProcessBuilder.aggregate_temporal_period>`, :py:meth:`aggregate_temporal_period() <openeo.processes.aggregate_temporal_period>`, :py:meth:`DataCube.aggregate_temporal_period() <openeo.rest.datacube.DataCube.aggregate_temporal_period>`
+    *   - `all <https://processes.openeo.org/#all>`_
+        - :py:meth:`ProcessBuilder.all() <openeo.processes.ProcessBuilder.all>`, :py:meth:`all() <openeo.processes.all>`
     *   - `and <https://processes.openeo.org/#and>`_
         - :py:meth:`DataCube.logical_and() <openeo.rest.datacube.DataCube.logical_and>`, :py:meth:`DataCube.__and__() <openeo.rest.datacube.DataCube.__and__>`
+    *   - `and_ <https://processes.openeo.org/#and_>`_
+        - :py:meth:`ProcessBuilder.and_() <openeo.processes.ProcessBuilder.and_>`, :py:meth:`and_() <openeo.processes.and_>`
+    *   - `anomaly <https://processes.openeo.org/#anomaly>`_
+        - :py:meth:`ProcessBuilder.anomaly() <openeo.processes.ProcessBuilder.anomaly>`, :py:meth:`anomaly() <openeo.processes.anomaly>`
+    *   - `any <https://processes.openeo.org/#any>`_
+        - :py:meth:`ProcessBuilder.any() <openeo.processes.ProcessBuilder.any>`, :py:meth:`any() <openeo.processes.any>`
     *   - `apply <https://processes.openeo.org/#apply>`_
-        - :py:meth:`DataCube.apply() <openeo.rest.datacube.DataCube.apply>`
+        - :py:meth:`ProcessBuilder.apply() <openeo.processes.ProcessBuilder.apply>`, :py:meth:`apply() <openeo.processes.apply>`, :py:meth:`DataCube.apply() <openeo.rest.datacube.DataCube.apply>`
     *   - `apply_dimension <https://processes.openeo.org/#apply_dimension>`_
-        - :py:meth:`DataCube.apply_dimension() <openeo.rest.datacube.DataCube.apply_dimension>`
+        - :py:meth:`ProcessBuilder.apply_dimension() <openeo.processes.ProcessBuilder.apply_dimension>`, :py:meth:`apply_dimension() <openeo.processes.apply_dimension>`, :py:meth:`DataCube.apply_dimension() <openeo.rest.datacube.DataCube.apply_dimension>`
     *   - `apply_kernel <https://processes.openeo.org/#apply_kernel>`_
-        - :py:meth:`DataCube.apply_kernel() <openeo.rest.datacube.DataCube.apply_kernel>`
+        - :py:meth:`ProcessBuilder.apply_kernel() <openeo.processes.ProcessBuilder.apply_kernel>`, :py:meth:`apply_kernel() <openeo.processes.apply_kernel>`, :py:meth:`DataCube.apply_kernel() <openeo.rest.datacube.DataCube.apply_kernel>`
     *   - `apply_neighborhood <https://processes.openeo.org/#apply_neighborhood>`_
-        - :py:meth:`DataCube.apply_neighborhood() <openeo.rest.datacube.DataCube.apply_neighborhood>`
+        - :py:meth:`ProcessBuilder.apply_neighborhood() <openeo.processes.ProcessBuilder.apply_neighborhood>`, :py:meth:`apply_neighborhood() <openeo.processes.apply_neighborhood>`, :py:meth:`DataCube.apply_neighborhood() <openeo.rest.datacube.DataCube.apply_neighborhood>`
+    *   - `arccos <https://processes.openeo.org/#arccos>`_
+        - :py:meth:`ProcessBuilder.arccos() <openeo.processes.ProcessBuilder.arccos>`, :py:meth:`arccos() <openeo.processes.arccos>`
+    *   - `arcosh <https://processes.openeo.org/#arcosh>`_
+        - :py:meth:`ProcessBuilder.arcosh() <openeo.processes.ProcessBuilder.arcosh>`, :py:meth:`arcosh() <openeo.processes.arcosh>`
+    *   - `arcsin <https://processes.openeo.org/#arcsin>`_
+        - :py:meth:`ProcessBuilder.arcsin() <openeo.processes.ProcessBuilder.arcsin>`, :py:meth:`arcsin() <openeo.processes.arcsin>`
+    *   - `arctan <https://processes.openeo.org/#arctan>`_
+        - :py:meth:`ProcessBuilder.arctan() <openeo.processes.ProcessBuilder.arctan>`, :py:meth:`arctan() <openeo.processes.arctan>`
+    *   - `arctan2 <https://processes.openeo.org/#arctan2>`_
+        - :py:meth:`ProcessBuilder.arctan2() <openeo.processes.ProcessBuilder.arctan2>`, :py:meth:`arctan2() <openeo.processes.arctan2>`
     *   - `ard_normalized_radar_backscatter <https://processes.openeo.org/#ard_normalized_radar_backscatter>`_
-        - :py:meth:`DataCube.ard_normalized_radar_backscatter() <openeo.rest.datacube.DataCube.ard_normalized_radar_backscatter>`
+        - :py:meth:`ProcessBuilder.ard_normalized_radar_backscatter() <openeo.processes.ProcessBuilder.ard_normalized_radar_backscatter>`, :py:meth:`ard_normalized_radar_backscatter() <openeo.processes.ard_normalized_radar_backscatter>`, :py:meth:`DataCube.ard_normalized_radar_backscatter() <openeo.rest.datacube.DataCube.ard_normalized_radar_backscatter>`
     *   - `ard_surface_reflectance <https://processes.openeo.org/#ard_surface_reflectance>`_
-        - :py:meth:`DataCube.ard_surface_reflectance() <openeo.rest.datacube.DataCube.ard_surface_reflectance>`
+        - :py:meth:`ProcessBuilder.ard_surface_reflectance() <openeo.processes.ProcessBuilder.ard_surface_reflectance>`, :py:meth:`ard_surface_reflectance() <openeo.processes.ard_surface_reflectance>`, :py:meth:`DataCube.ard_surface_reflectance() <openeo.rest.datacube.DataCube.ard_surface_reflectance>`
+    *   - `array_append <https://processes.openeo.org/#array_append>`_
+        - :py:meth:`ProcessBuilder.array_append() <openeo.processes.ProcessBuilder.array_append>`, :py:meth:`array_append() <openeo.processes.array_append>`
+    *   - `array_apply <https://processes.openeo.org/#array_apply>`_
+        - :py:meth:`ProcessBuilder.array_apply() <openeo.processes.ProcessBuilder.array_apply>`, :py:meth:`array_apply() <openeo.processes.array_apply>`
+    *   - `array_concat <https://processes.openeo.org/#array_concat>`_
+        - :py:meth:`ProcessBuilder.array_concat() <openeo.processes.ProcessBuilder.array_concat>`, :py:meth:`array_concat() <openeo.processes.array_concat>`
+    *   - `array_contains <https://processes.openeo.org/#array_contains>`_
+        - :py:meth:`ProcessBuilder.array_contains() <openeo.processes.ProcessBuilder.array_contains>`, :py:meth:`array_contains() <openeo.processes.array_contains>`
+    *   - `array_create <https://processes.openeo.org/#array_create>`_
+        - :py:meth:`ProcessBuilder.array_create() <openeo.processes.ProcessBuilder.array_create>`, :py:meth:`array_create() <openeo.processes.array_create>`
+    *   - `array_create_labeled <https://processes.openeo.org/#array_create_labeled>`_
+        - :py:meth:`ProcessBuilder.array_create_labeled() <openeo.processes.ProcessBuilder.array_create_labeled>`, :py:meth:`array_create_labeled() <openeo.processes.array_create_labeled>`
+    *   - `array_element <https://processes.openeo.org/#array_element>`_
+        - :py:meth:`ProcessBuilder.__getitem__() <openeo.processes.ProcessBuilder.__getitem__>`, :py:meth:`ProcessBuilder.array_element() <openeo.processes.ProcessBuilder.array_element>`, :py:meth:`array_element() <openeo.processes.array_element>`
+    *   - `array_filter <https://processes.openeo.org/#array_filter>`_
+        - :py:meth:`ProcessBuilder.array_filter() <openeo.processes.ProcessBuilder.array_filter>`, :py:meth:`array_filter() <openeo.processes.array_filter>`
+    *   - `array_find <https://processes.openeo.org/#array_find>`_
+        - :py:meth:`ProcessBuilder.array_find() <openeo.processes.ProcessBuilder.array_find>`, :py:meth:`array_find() <openeo.processes.array_find>`
+    *   - `array_find_label <https://processes.openeo.org/#array_find_label>`_
+        - :py:meth:`ProcessBuilder.array_find_label() <openeo.processes.ProcessBuilder.array_find_label>`, :py:meth:`array_find_label() <openeo.processes.array_find_label>`
+    *   - `array_interpolate_linear <https://processes.openeo.org/#array_interpolate_linear>`_
+        - :py:meth:`ProcessBuilder.array_interpolate_linear() <openeo.processes.ProcessBuilder.array_interpolate_linear>`, :py:meth:`array_interpolate_linear() <openeo.processes.array_interpolate_linear>`
+    *   - `array_labels <https://processes.openeo.org/#array_labels>`_
+        - :py:meth:`ProcessBuilder.array_labels() <openeo.processes.ProcessBuilder.array_labels>`, :py:meth:`array_labels() <openeo.processes.array_labels>`
+    *   - `array_modify <https://processes.openeo.org/#array_modify>`_
+        - :py:meth:`ProcessBuilder.array_modify() <openeo.processes.ProcessBuilder.array_modify>`, :py:meth:`array_modify() <openeo.processes.array_modify>`
+    *   - `arsinh <https://processes.openeo.org/#arsinh>`_
+        - :py:meth:`ProcessBuilder.arsinh() <openeo.processes.ProcessBuilder.arsinh>`, :py:meth:`arsinh() <openeo.processes.arsinh>`
+    *   - `artanh <https://processes.openeo.org/#artanh>`_
+        - :py:meth:`ProcessBuilder.artanh() <openeo.processes.ProcessBuilder.artanh>`, :py:meth:`artanh() <openeo.processes.artanh>`
     *   - `atmospheric_correction <https://processes.openeo.org/#atmospheric_correction>`_
-        - :py:meth:`DataCube.atmospheric_correction() <openeo.rest.datacube.DataCube.atmospheric_correction>`
+        - :py:meth:`ProcessBuilder.atmospheric_correction() <openeo.processes.ProcessBuilder.atmospheric_correction>`, :py:meth:`atmospheric_correction() <openeo.processes.atmospheric_correction>`, :py:meth:`DataCube.atmospheric_correction() <openeo.rest.datacube.DataCube.atmospheric_correction>`
+    *   - `between <https://processes.openeo.org/#between>`_
+        - :py:meth:`ProcessBuilder.between() <openeo.processes.ProcessBuilder.between>`, :py:meth:`between() <openeo.processes.between>`
+    *   - `ceil <https://processes.openeo.org/#ceil>`_
+        - :py:meth:`ProcessBuilder.ceil() <openeo.processes.ProcessBuilder.ceil>`, :py:meth:`ceil() <openeo.processes.ceil>`
+    *   - `climatological_normal <https://processes.openeo.org/#climatological_normal>`_
+        - :py:meth:`ProcessBuilder.climatological_normal() <openeo.processes.ProcessBuilder.climatological_normal>`, :py:meth:`climatological_normal() <openeo.processes.climatological_normal>`
+    *   - `clip <https://processes.openeo.org/#clip>`_
+        - :py:meth:`ProcessBuilder.clip() <openeo.processes.ProcessBuilder.clip>`, :py:meth:`clip() <openeo.processes.clip>`
+    *   - `cloud_detection <https://processes.openeo.org/#cloud_detection>`_
+        - :py:meth:`ProcessBuilder.cloud_detection() <openeo.processes.ProcessBuilder.cloud_detection>`, :py:meth:`cloud_detection() <openeo.processes.cloud_detection>`
+    *   - `constant <https://processes.openeo.org/#constant>`_
+        - :py:meth:`ProcessBuilder.constant() <openeo.processes.ProcessBuilder.constant>`, :py:meth:`constant() <openeo.processes.constant>`
+    *   - `cos <https://processes.openeo.org/#cos>`_
+        - :py:meth:`ProcessBuilder.cos() <openeo.processes.ProcessBuilder.cos>`, :py:meth:`cos() <openeo.processes.cos>`
+    *   - `cosh <https://processes.openeo.org/#cosh>`_
+        - :py:meth:`ProcessBuilder.cosh() <openeo.processes.ProcessBuilder.cosh>`, :py:meth:`cosh() <openeo.processes.cosh>`
     *   - `count <https://processes.openeo.org/#count>`_
-        - :py:meth:`DataCube.count_time() <openeo.rest.datacube.DataCube.count_time>`
+        - :py:meth:`ProcessBuilder.count() <openeo.processes.ProcessBuilder.count>`, :py:meth:`count() <openeo.processes.count>`, :py:meth:`DataCube.count_time() <openeo.rest.datacube.DataCube.count_time>`
+    *   - `create_raster_cube <https://processes.openeo.org/#create_raster_cube>`_
+        - :py:meth:`ProcessBuilder.create_raster_cube() <openeo.processes.ProcessBuilder.create_raster_cube>`, :py:meth:`create_raster_cube() <openeo.processes.create_raster_cube>`
+    *   - `cummax <https://processes.openeo.org/#cummax>`_
+        - :py:meth:`ProcessBuilder.cummax() <openeo.processes.ProcessBuilder.cummax>`, :py:meth:`cummax() <openeo.processes.cummax>`
+    *   - `cummin <https://processes.openeo.org/#cummin>`_
+        - :py:meth:`ProcessBuilder.cummin() <openeo.processes.ProcessBuilder.cummin>`, :py:meth:`cummin() <openeo.processes.cummin>`
+    *   - `cumproduct <https://processes.openeo.org/#cumproduct>`_
+        - :py:meth:`ProcessBuilder.cumproduct() <openeo.processes.ProcessBuilder.cumproduct>`, :py:meth:`cumproduct() <openeo.processes.cumproduct>`
+    *   - `cumsum <https://processes.openeo.org/#cumsum>`_
+        - :py:meth:`ProcessBuilder.cumsum() <openeo.processes.ProcessBuilder.cumsum>`, :py:meth:`cumsum() <openeo.processes.cumsum>`
+    *   - `date_shift <https://processes.openeo.org/#date_shift>`_
+        - :py:meth:`ProcessBuilder.date_shift() <openeo.processes.ProcessBuilder.date_shift>`, :py:meth:`date_shift() <openeo.processes.date_shift>`
     *   - `dimension_labels <https://processes.openeo.org/#dimension_labels>`_
-        - :py:meth:`DataCube.dimension_labels() <openeo.rest.datacube.DataCube.dimension_labels>`
+        - :py:meth:`ProcessBuilder.dimension_labels() <openeo.processes.ProcessBuilder.dimension_labels>`, :py:meth:`dimension_labels() <openeo.processes.dimension_labels>`, :py:meth:`DataCube.dimension_labels() <openeo.rest.datacube.DataCube.dimension_labels>`
     *   - `divide <https://processes.openeo.org/#divide>`_
-        - :py:meth:`DataCube.divide() <openeo.rest.datacube.DataCube.divide>`, :py:meth:`DataCube.__truediv__() <openeo.rest.datacube.DataCube.__truediv__>`, :py:meth:`DataCube.__rtruediv__() <openeo.rest.datacube.DataCube.__rtruediv__>`
+        - :py:meth:`ProcessBuilder.__truediv__() <openeo.processes.ProcessBuilder.__truediv__>`, :py:meth:`ProcessBuilder.__rtruediv__() <openeo.processes.ProcessBuilder.__rtruediv__>`, :py:meth:`ProcessBuilder.divide() <openeo.processes.ProcessBuilder.divide>`, :py:meth:`divide() <openeo.processes.divide>`, :py:meth:`DataCube.divide() <openeo.rest.datacube.DataCube.divide>`, :py:meth:`DataCube.__truediv__() <openeo.rest.datacube.DataCube.__truediv__>`, :py:meth:`DataCube.__rtruediv__() <openeo.rest.datacube.DataCube.__rtruediv__>`
     *   - `drop_dimension <https://processes.openeo.org/#drop_dimension>`_
-        - :py:meth:`DataCube.drop_dimension() <openeo.rest.datacube.DataCube.drop_dimension>`
+        - :py:meth:`ProcessBuilder.drop_dimension() <openeo.processes.ProcessBuilder.drop_dimension>`, :py:meth:`drop_dimension() <openeo.processes.drop_dimension>`, :py:meth:`DataCube.drop_dimension() <openeo.rest.datacube.DataCube.drop_dimension>`
+    *   - `e <https://processes.openeo.org/#e>`_
+        - :py:meth:`ProcessBuilder.e() <openeo.processes.ProcessBuilder.e>`, :py:meth:`e() <openeo.processes.e>`
     *   - `eq <https://processes.openeo.org/#eq>`_
-        - :py:meth:`DataCube.__eq__() <openeo.rest.datacube.DataCube.__eq__>`
+        - :py:meth:`ProcessBuilder.__eq__() <openeo.processes.ProcessBuilder.__eq__>`, :py:meth:`ProcessBuilder.eq() <openeo.processes.ProcessBuilder.eq>`, :py:meth:`eq() <openeo.processes.eq>`, :py:meth:`DataCube.__eq__() <openeo.rest.datacube.DataCube.__eq__>`
+    *   - `exp <https://processes.openeo.org/#exp>`_
+        - :py:meth:`ProcessBuilder.exp() <openeo.processes.ProcessBuilder.exp>`, :py:meth:`exp() <openeo.processes.exp>`
+    *   - `extrema <https://processes.openeo.org/#extrema>`_
+        - :py:meth:`ProcessBuilder.extrema() <openeo.processes.ProcessBuilder.extrema>`, :py:meth:`extrema() <openeo.processes.extrema>`
     *   - `filter_bands <https://processes.openeo.org/#filter_bands>`_
-        - :py:meth:`DataCube.filter_bands() <openeo.rest.datacube.DataCube.filter_bands>`
+        - :py:meth:`ProcessBuilder.filter_bands() <openeo.processes.ProcessBuilder.filter_bands>`, :py:meth:`filter_bands() <openeo.processes.filter_bands>`, :py:meth:`DataCube.filter_bands() <openeo.rest.datacube.DataCube.filter_bands>`
     *   - `filter_bbox <https://processes.openeo.org/#filter_bbox>`_
-        - :py:meth:`DataCube.filter_bbox() <openeo.rest.datacube.DataCube.filter_bbox>`
+        - :py:meth:`ProcessBuilder.filter_bbox() <openeo.processes.ProcessBuilder.filter_bbox>`, :py:meth:`filter_bbox() <openeo.processes.filter_bbox>`, :py:meth:`DataCube.filter_bbox() <openeo.rest.datacube.DataCube.filter_bbox>`
+    *   - `filter_labels <https://processes.openeo.org/#filter_labels>`_
+        - :py:meth:`ProcessBuilder.filter_labels() <openeo.processes.ProcessBuilder.filter_labels>`, :py:meth:`filter_labels() <openeo.processes.filter_labels>`
     *   - `filter_spatial <https://processes.openeo.org/#filter_spatial>`_
-        - :py:meth:`DataCube.filter_spatial() <openeo.rest.datacube.DataCube.filter_spatial>`
+        - :py:meth:`ProcessBuilder.filter_spatial() <openeo.processes.ProcessBuilder.filter_spatial>`, :py:meth:`filter_spatial() <openeo.processes.filter_spatial>`, :py:meth:`DataCube.filter_spatial() <openeo.rest.datacube.DataCube.filter_spatial>`
     *   - `filter_temporal <https://processes.openeo.org/#filter_temporal>`_
-        - :py:meth:`DataCube.filter_temporal() <openeo.rest.datacube.DataCube.filter_temporal>`
+        - :py:meth:`ProcessBuilder.filter_temporal() <openeo.processes.ProcessBuilder.filter_temporal>`, :py:meth:`filter_temporal() <openeo.processes.filter_temporal>`, :py:meth:`DataCube.filter_temporal() <openeo.rest.datacube.DataCube.filter_temporal>`
+    *   - `first <https://processes.openeo.org/#first>`_
+        - :py:meth:`ProcessBuilder.first() <openeo.processes.ProcessBuilder.first>`, :py:meth:`first() <openeo.processes.first>`
     *   - `fit_class_random_forest <https://processes.openeo.org/#fit_class_random_forest>`_
-        - :py:meth:`VectorCube.fit_class_random_forest() <openeo.rest.vectorcube.VectorCube.fit_class_random_forest>`
+        - :py:meth:`ProcessBuilder.fit_class_random_forest() <openeo.processes.ProcessBuilder.fit_class_random_forest>`, :py:meth:`fit_class_random_forest() <openeo.processes.fit_class_random_forest>`, :py:meth:`VectorCube.fit_class_random_forest() <openeo.rest.vectorcube.VectorCube.fit_class_random_forest>`
     *   - `fit_curve <https://processes.openeo.org/#fit_curve>`_
-        - :py:meth:`DataCube.fit_curve() <openeo.rest.datacube.DataCube.fit_curve>`
+        - :py:meth:`ProcessBuilder.fit_curve() <openeo.processes.ProcessBuilder.fit_curve>`, :py:meth:`fit_curve() <openeo.processes.fit_curve>`, :py:meth:`DataCube.fit_curve() <openeo.rest.datacube.DataCube.fit_curve>`
     *   - `fit_regr_random_forest <https://processes.openeo.org/#fit_regr_random_forest>`_
-        - :py:meth:`VectorCube.fit_regr_random_forest() <openeo.rest.vectorcube.VectorCube.fit_regr_random_forest>`
+        - :py:meth:`ProcessBuilder.fit_regr_random_forest() <openeo.processes.ProcessBuilder.fit_regr_random_forest>`, :py:meth:`fit_regr_random_forest() <openeo.processes.fit_regr_random_forest>`, :py:meth:`VectorCube.fit_regr_random_forest() <openeo.rest.vectorcube.VectorCube.fit_regr_random_forest>`
     *   - `flatten_dimensions <https://processes.openeo.org/#flatten_dimensions>`_
-        - :py:meth:`DataCube.flatten_dimensions() <openeo.rest.datacube.DataCube.flatten_dimensions>`
+        - :py:meth:`ProcessBuilder.flatten_dimensions() <openeo.processes.ProcessBuilder.flatten_dimensions>`, :py:meth:`flatten_dimensions() <openeo.processes.flatten_dimensions>`, :py:meth:`DataCube.flatten_dimensions() <openeo.rest.datacube.DataCube.flatten_dimensions>`
+    *   - `floor <https://processes.openeo.org/#floor>`_
+        - :py:meth:`ProcessBuilder.floor() <openeo.processes.ProcessBuilder.floor>`, :py:meth:`floor() <openeo.processes.floor>`
     *   - `ge <https://processes.openeo.org/#ge>`_
-        - :py:meth:`DataCube.__ge__() <openeo.rest.datacube.DataCube.__ge__>`
+        - :py:meth:`ProcessBuilder.__ge__() <openeo.processes.ProcessBuilder.__ge__>`, :py:meth:`DataCube.__ge__() <openeo.rest.datacube.DataCube.__ge__>`
     *   - `gt <https://processes.openeo.org/#gt>`_
-        - :py:meth:`DataCube.__gt__() <openeo.rest.datacube.DataCube.__gt__>`
+        - :py:meth:`ProcessBuilder.__gt__() <openeo.processes.ProcessBuilder.__gt__>`, :py:meth:`ProcessBuilder.gt() <openeo.processes.ProcessBuilder.gt>`, :py:meth:`gt() <openeo.processes.gt>`, :py:meth:`DataCube.__gt__() <openeo.rest.datacube.DataCube.__gt__>`
+    *   - `gte <https://processes.openeo.org/#gte>`_
+        - :py:meth:`ProcessBuilder.gte() <openeo.processes.ProcessBuilder.gte>`, :py:meth:`gte() <openeo.processes.gte>`
+    *   - `if_ <https://processes.openeo.org/#if_>`_
+        - :py:meth:`ProcessBuilder.if_() <openeo.processes.ProcessBuilder.if_>`, :py:meth:`if_() <openeo.processes.if_>`
+    *   - `inspect <https://processes.openeo.org/#inspect>`_
+        - :py:meth:`ProcessBuilder.inspect() <openeo.processes.ProcessBuilder.inspect>`, :py:meth:`inspect() <openeo.processes.inspect>`
+    *   - `int <https://processes.openeo.org/#int>`_
+        - :py:meth:`ProcessBuilder.int() <openeo.processes.ProcessBuilder.int>`, :py:meth:`int() <openeo.processes.int>`
+    *   - `is_infinite <https://processes.openeo.org/#is_infinite>`_
+        - :py:meth:`ProcessBuilder.is_infinite() <openeo.processes.ProcessBuilder.is_infinite>`, :py:meth:`is_infinite() <openeo.processes.is_infinite>`
+    *   - `is_nan <https://processes.openeo.org/#is_nan>`_
+        - :py:meth:`ProcessBuilder.is_nan() <openeo.processes.ProcessBuilder.is_nan>`, :py:meth:`is_nan() <openeo.processes.is_nan>`
+    *   - `is_nodata <https://processes.openeo.org/#is_nodata>`_
+        - :py:meth:`ProcessBuilder.is_nodata() <openeo.processes.ProcessBuilder.is_nodata>`, :py:meth:`is_nodata() <openeo.processes.is_nodata>`
+    *   - `is_valid <https://processes.openeo.org/#is_valid>`_
+        - :py:meth:`ProcessBuilder.is_valid() <openeo.processes.ProcessBuilder.is_valid>`, :py:meth:`is_valid() <openeo.processes.is_valid>`
+    *   - `last <https://processes.openeo.org/#last>`_
+        - :py:meth:`ProcessBuilder.last() <openeo.processes.ProcessBuilder.last>`, :py:meth:`last() <openeo.processes.last>`
     *   - `le <https://processes.openeo.org/#le>`_
         - :py:meth:`DataCube.__le__() <openeo.rest.datacube.DataCube.__le__>`
     *   - `linear_scale_range <https://processes.openeo.org/#linear_scale_range>`_
-        - :py:meth:`DataCube.linear_scale_range() <openeo.rest.datacube.DataCube.linear_scale_range>`
+        - :py:meth:`ProcessBuilder.linear_scale_range() <openeo.processes.ProcessBuilder.linear_scale_range>`, :py:meth:`linear_scale_range() <openeo.processes.linear_scale_range>`, :py:meth:`DataCube.linear_scale_range() <openeo.rest.datacube.DataCube.linear_scale_range>`
     *   - `ln <https://processes.openeo.org/#ln>`_
-        - :py:meth:`DataCube.ln() <openeo.rest.datacube.DataCube.ln>`
+        - :py:meth:`ProcessBuilder.ln() <openeo.processes.ProcessBuilder.ln>`, :py:meth:`ln() <openeo.processes.ln>`, :py:meth:`DataCube.ln() <openeo.rest.datacube.DataCube.ln>`
     *   - `load_collection <https://processes.openeo.org/#load_collection>`_
-        - :py:meth:`DataCube.load_collection() <openeo.rest.datacube.DataCube.load_collection>`
+        - :py:meth:`ProcessBuilder.load_collection() <openeo.processes.ProcessBuilder.load_collection>`, :py:meth:`load_collection() <openeo.processes.load_collection>`, :py:meth:`DataCube.load_collection() <openeo.rest.datacube.DataCube.load_collection>`
     *   - `load_ml_model <https://processes.openeo.org/#load_ml_model>`_
-        - :py:meth:`MlModel.load_ml_model() <openeo.rest.mlmodel.MlModel.load_ml_model>`
+        - :py:meth:`ProcessBuilder.load_ml_model() <openeo.processes.ProcessBuilder.load_ml_model>`, :py:meth:`load_ml_model() <openeo.processes.load_ml_model>`, :py:meth:`MlModel.load_ml_model() <openeo.rest.mlmodel.MlModel.load_ml_model>`
+    *   - `load_result <https://processes.openeo.org/#load_result>`_
+        - :py:meth:`ProcessBuilder.load_result() <openeo.processes.ProcessBuilder.load_result>`, :py:meth:`load_result() <openeo.processes.load_result>`
+    *   - `load_uploaded_files <https://processes.openeo.org/#load_uploaded_files>`_
+        - :py:meth:`ProcessBuilder.load_uploaded_files() <openeo.processes.ProcessBuilder.load_uploaded_files>`, :py:meth:`load_uploaded_files() <openeo.processes.load_uploaded_files>`
     *   - `log <https://processes.openeo.org/#log>`_
-        - :py:meth:`DataCube.logarithm() <openeo.rest.datacube.DataCube.logarithm>`, :py:meth:`DataCube.log2() <openeo.rest.datacube.DataCube.log2>`, :py:meth:`DataCube.log10() <openeo.rest.datacube.DataCube.log10>`
+        - :py:meth:`ProcessBuilder.log() <openeo.processes.ProcessBuilder.log>`, :py:meth:`log() <openeo.processes.log>`, :py:meth:`DataCube.logarithm() <openeo.rest.datacube.DataCube.logarithm>`, :py:meth:`DataCube.log2() <openeo.rest.datacube.DataCube.log2>`, :py:meth:`DataCube.log10() <openeo.rest.datacube.DataCube.log10>`
     *   - `lt <https://processes.openeo.org/#lt>`_
-        - :py:meth:`DataCube.__lt__() <openeo.rest.datacube.DataCube.__lt__>`
+        - :py:meth:`ProcessBuilder.__lt__() <openeo.processes.ProcessBuilder.__lt__>`, :py:meth:`ProcessBuilder.lt() <openeo.processes.ProcessBuilder.lt>`, :py:meth:`lt() <openeo.processes.lt>`, :py:meth:`DataCube.__lt__() <openeo.rest.datacube.DataCube.__lt__>`
+    *   - `lte <https://processes.openeo.org/#lte>`_
+        - :py:meth:`ProcessBuilder.__le__() <openeo.processes.ProcessBuilder.__le__>`, :py:meth:`ProcessBuilder.lte() <openeo.processes.ProcessBuilder.lte>`, :py:meth:`lte() <openeo.processes.lte>`
     *   - `mask <https://processes.openeo.org/#mask>`_
-        - :py:meth:`DataCube.mask() <openeo.rest.datacube.DataCube.mask>`
+        - :py:meth:`ProcessBuilder.mask() <openeo.processes.ProcessBuilder.mask>`, :py:meth:`mask() <openeo.processes.mask>`, :py:meth:`DataCube.mask() <openeo.rest.datacube.DataCube.mask>`
     *   - `mask_polygon <https://processes.openeo.org/#mask_polygon>`_
-        - :py:meth:`DataCube.mask_polygon() <openeo.rest.datacube.DataCube.mask_polygon>`
+        - :py:meth:`ProcessBuilder.mask_polygon() <openeo.processes.ProcessBuilder.mask_polygon>`, :py:meth:`mask_polygon() <openeo.processes.mask_polygon>`, :py:meth:`DataCube.mask_polygon() <openeo.rest.datacube.DataCube.mask_polygon>`
     *   - `max <https://processes.openeo.org/#max>`_
-        - :py:meth:`DataCube.max_time() <openeo.rest.datacube.DataCube.max_time>`
+        - :py:meth:`ProcessBuilder.max() <openeo.processes.ProcessBuilder.max>`, :py:meth:`max() <openeo.processes.max>`, :py:meth:`DataCube.max_time() <openeo.rest.datacube.DataCube.max_time>`
     *   - `mean <https://processes.openeo.org/#mean>`_
-        - :py:meth:`DataCube.mean_time() <openeo.rest.datacube.DataCube.mean_time>`
+        - :py:meth:`ProcessBuilder.mean() <openeo.processes.ProcessBuilder.mean>`, :py:meth:`mean() <openeo.processes.mean>`, :py:meth:`DataCube.mean_time() <openeo.rest.datacube.DataCube.mean_time>`
     *   - `median <https://processes.openeo.org/#median>`_
-        - :py:meth:`DataCube.median_time() <openeo.rest.datacube.DataCube.median_time>`
+        - :py:meth:`ProcessBuilder.median() <openeo.processes.ProcessBuilder.median>`, :py:meth:`median() <openeo.processes.median>`, :py:meth:`DataCube.median_time() <openeo.rest.datacube.DataCube.median_time>`
     *   - `merge_cubes <https://processes.openeo.org/#merge_cubes>`_
-        - :py:meth:`DataCube.merge_cubes() <openeo.rest.datacube.DataCube.merge_cubes>`
+        - :py:meth:`ProcessBuilder.merge_cubes() <openeo.processes.ProcessBuilder.merge_cubes>`, :py:meth:`merge_cubes() <openeo.processes.merge_cubes>`, :py:meth:`DataCube.merge_cubes() <openeo.rest.datacube.DataCube.merge_cubes>`
     *   - `min <https://processes.openeo.org/#min>`_
-        - :py:meth:`DataCube.min_time() <openeo.rest.datacube.DataCube.min_time>`
+        - :py:meth:`ProcessBuilder.min() <openeo.processes.ProcessBuilder.min>`, :py:meth:`min() <openeo.processes.min>`, :py:meth:`DataCube.min_time() <openeo.rest.datacube.DataCube.min_time>`
+    *   - `mod <https://processes.openeo.org/#mod>`_
+        - :py:meth:`ProcessBuilder.mod() <openeo.processes.ProcessBuilder.mod>`, :py:meth:`mod() <openeo.processes.mod>`
     *   - `multiply <https://processes.openeo.org/#multiply>`_
-        - :py:meth:`DataCube.multiply() <openeo.rest.datacube.DataCube.multiply>`, :py:meth:`DataCube.__neg__() <openeo.rest.datacube.DataCube.__neg__>`, :py:meth:`DataCube.__mul__() <openeo.rest.datacube.DataCube.__mul__>`, :py:meth:`DataCube.__rmul__() <openeo.rest.datacube.DataCube.__rmul__>`
+        - :py:meth:`ProcessBuilder.__mul__() <openeo.processes.ProcessBuilder.__mul__>`, :py:meth:`ProcessBuilder.__rmul__() <openeo.processes.ProcessBuilder.__rmul__>`, :py:meth:`ProcessBuilder.__neg__() <openeo.processes.ProcessBuilder.__neg__>`, :py:meth:`ProcessBuilder.multiply() <openeo.processes.ProcessBuilder.multiply>`, :py:meth:`multiply() <openeo.processes.multiply>`, :py:meth:`DataCube.multiply() <openeo.rest.datacube.DataCube.multiply>`, :py:meth:`DataCube.__neg__() <openeo.rest.datacube.DataCube.__neg__>`, :py:meth:`DataCube.__mul__() <openeo.rest.datacube.DataCube.__mul__>`, :py:meth:`DataCube.__rmul__() <openeo.rest.datacube.DataCube.__rmul__>`
+    *   - `nan <https://processes.openeo.org/#nan>`_
+        - :py:meth:`ProcessBuilder.nan() <openeo.processes.ProcessBuilder.nan>`, :py:meth:`nan() <openeo.processes.nan>`
     *   - `ndvi <https://processes.openeo.org/#ndvi>`_
-        - :py:meth:`DataCube.ndvi() <openeo.rest.datacube.DataCube.ndvi>`
+        - :py:meth:`ProcessBuilder.ndvi() <openeo.processes.ProcessBuilder.ndvi>`, :py:meth:`ndvi() <openeo.processes.ndvi>`, :py:meth:`DataCube.ndvi() <openeo.rest.datacube.DataCube.ndvi>`
     *   - `neq <https://processes.openeo.org/#neq>`_
-        - :py:meth:`DataCube.__ne__() <openeo.rest.datacube.DataCube.__ne__>`
+        - :py:meth:`ProcessBuilder.__ne__() <openeo.processes.ProcessBuilder.__ne__>`, :py:meth:`ProcessBuilder.neq() <openeo.processes.ProcessBuilder.neq>`, :py:meth:`neq() <openeo.processes.neq>`, :py:meth:`DataCube.__ne__() <openeo.rest.datacube.DataCube.__ne__>`
     *   - `normalized_difference <https://processes.openeo.org/#normalized_difference>`_
-        - :py:meth:`DataCube.normalized_difference() <openeo.rest.datacube.DataCube.normalized_difference>`
+        - :py:meth:`ProcessBuilder.normalized_difference() <openeo.processes.ProcessBuilder.normalized_difference>`, :py:meth:`normalized_difference() <openeo.processes.normalized_difference>`, :py:meth:`DataCube.normalized_difference() <openeo.rest.datacube.DataCube.normalized_difference>`
     *   - `not <https://processes.openeo.org/#not>`_
         - :py:meth:`DataCube.__invert__() <openeo.rest.datacube.DataCube.__invert__>`
+    *   - `not_ <https://processes.openeo.org/#not_>`_
+        - :py:meth:`ProcessBuilder.not_() <openeo.processes.ProcessBuilder.not_>`, :py:meth:`not_() <openeo.processes.not_>`
     *   - `or <https://processes.openeo.org/#or>`_
         - :py:meth:`DataCube.logical_or() <openeo.rest.datacube.DataCube.logical_or>`, :py:meth:`DataCube.__or__() <openeo.rest.datacube.DataCube.__or__>`
+    *   - `or_ <https://processes.openeo.org/#or_>`_
+        - :py:meth:`ProcessBuilder.or_() <openeo.processes.ProcessBuilder.or_>`, :py:meth:`or_() <openeo.processes.or_>`
+    *   - `order <https://processes.openeo.org/#order>`_
+        - :py:meth:`ProcessBuilder.order() <openeo.processes.ProcessBuilder.order>`, :py:meth:`order() <openeo.processes.order>`
+    *   - `pi <https://processes.openeo.org/#pi>`_
+        - :py:meth:`ProcessBuilder.pi() <openeo.processes.ProcessBuilder.pi>`, :py:meth:`pi() <openeo.processes.pi>`
     *   - `power <https://processes.openeo.org/#power>`_
-        - :py:meth:`DataCube.__rpow__() <openeo.rest.datacube.DataCube.__rpow__>`, :py:meth:`DataCube.__pow__() <openeo.rest.datacube.DataCube.__pow__>`, :py:meth:`DataCube.power() <openeo.rest.datacube.DataCube.power>`
+        - :py:meth:`ProcessBuilder.__pow__() <openeo.processes.ProcessBuilder.__pow__>`, :py:meth:`ProcessBuilder.power() <openeo.processes.ProcessBuilder.power>`, :py:meth:`power() <openeo.processes.power>`, :py:meth:`DataCube.__rpow__() <openeo.rest.datacube.DataCube.__rpow__>`, :py:meth:`DataCube.__pow__() <openeo.rest.datacube.DataCube.__pow__>`, :py:meth:`DataCube.power() <openeo.rest.datacube.DataCube.power>`
     *   - `predict_curve <https://processes.openeo.org/#predict_curve>`_
-        - :py:meth:`DataCube.predict_curve() <openeo.rest.datacube.DataCube.predict_curve>`
+        - :py:meth:`ProcessBuilder.predict_curve() <openeo.processes.ProcessBuilder.predict_curve>`, :py:meth:`predict_curve() <openeo.processes.predict_curve>`, :py:meth:`DataCube.predict_curve() <openeo.rest.datacube.DataCube.predict_curve>`
     *   - `predict_random_forest <https://processes.openeo.org/#predict_random_forest>`_
-        - :py:meth:`DataCube.predict_random_forest() <openeo.rest.datacube.DataCube.predict_random_forest>`
+        - :py:meth:`ProcessBuilder.predict_random_forest() <openeo.processes.ProcessBuilder.predict_random_forest>`, :py:meth:`predict_random_forest() <openeo.processes.predict_random_forest>`, :py:meth:`DataCube.predict_random_forest() <openeo.rest.datacube.DataCube.predict_random_forest>`
+    *   - `product <https://processes.openeo.org/#product>`_
+        - :py:meth:`ProcessBuilder.product() <openeo.processes.ProcessBuilder.product>`, :py:meth:`product() <openeo.processes.product>`
+    *   - `quantiles <https://processes.openeo.org/#quantiles>`_
+        - :py:meth:`ProcessBuilder.quantiles() <openeo.processes.ProcessBuilder.quantiles>`, :py:meth:`quantiles() <openeo.processes.quantiles>`
+    *   - `rearrange <https://processes.openeo.org/#rearrange>`_
+        - :py:meth:`ProcessBuilder.rearrange() <openeo.processes.ProcessBuilder.rearrange>`, :py:meth:`rearrange() <openeo.processes.rearrange>`
     *   - `reduce_dimension <https://processes.openeo.org/#reduce_dimension>`_
-        - :py:meth:`DataCube.reduce_dimension() <openeo.rest.datacube.DataCube.reduce_dimension>`
+        - :py:meth:`ProcessBuilder.reduce_dimension() <openeo.processes.ProcessBuilder.reduce_dimension>`, :py:meth:`reduce_dimension() <openeo.processes.reduce_dimension>`, :py:meth:`DataCube.reduce_dimension() <openeo.rest.datacube.DataCube.reduce_dimension>`
+    *   - `reduce_spatial <https://processes.openeo.org/#reduce_spatial>`_
+        - :py:meth:`ProcessBuilder.reduce_spatial() <openeo.processes.ProcessBuilder.reduce_spatial>`, :py:meth:`reduce_spatial() <openeo.processes.reduce_spatial>`
     *   - `rename_dimension <https://processes.openeo.org/#rename_dimension>`_
-        - :py:meth:`DataCube.rename_dimension() <openeo.rest.datacube.DataCube.rename_dimension>`
+        - :py:meth:`ProcessBuilder.rename_dimension() <openeo.processes.ProcessBuilder.rename_dimension>`, :py:meth:`rename_dimension() <openeo.processes.rename_dimension>`, :py:meth:`DataCube.rename_dimension() <openeo.rest.datacube.DataCube.rename_dimension>`
     *   - `rename_labels <https://processes.openeo.org/#rename_labels>`_
-        - :py:meth:`DataCube.rename_labels() <openeo.rest.datacube.DataCube.rename_labels>`
+        - :py:meth:`ProcessBuilder.rename_labels() <openeo.processes.ProcessBuilder.rename_labels>`, :py:meth:`rename_labels() <openeo.processes.rename_labels>`, :py:meth:`DataCube.rename_labels() <openeo.rest.datacube.DataCube.rename_labels>`
+    *   - `resample_cube_spatial <https://processes.openeo.org/#resample_cube_spatial>`_
+        - :py:meth:`ProcessBuilder.resample_cube_spatial() <openeo.processes.ProcessBuilder.resample_cube_spatial>`, :py:meth:`resample_cube_spatial() <openeo.processes.resample_cube_spatial>`
     *   - `resample_cube_temporal <https://processes.openeo.org/#resample_cube_temporal>`_
-        - :py:meth:`DataCube.resample_cube_temporal() <openeo.rest.datacube.DataCube.resample_cube_temporal>`
+        - :py:meth:`ProcessBuilder.resample_cube_temporal() <openeo.processes.ProcessBuilder.resample_cube_temporal>`, :py:meth:`resample_cube_temporal() <openeo.processes.resample_cube_temporal>`, :py:meth:`DataCube.resample_cube_temporal() <openeo.rest.datacube.DataCube.resample_cube_temporal>`
     *   - `resample_spatial <https://processes.openeo.org/#resample_spatial>`_
-        - :py:meth:`DataCube.resample_spatial() <openeo.rest.datacube.DataCube.resample_spatial>`
+        - :py:meth:`ProcessBuilder.resample_spatial() <openeo.processes.ProcessBuilder.resample_spatial>`, :py:meth:`resample_spatial() <openeo.processes.resample_spatial>`, :py:meth:`DataCube.resample_spatial() <openeo.rest.datacube.DataCube.resample_spatial>`
     *   - `resolution_merge <https://processes.openeo.org/#resolution_merge>`_
         - :py:meth:`DataCube.resolution_merge() <openeo.rest.datacube.DataCube.resolution_merge>`
+    *   - `round <https://processes.openeo.org/#round>`_
+        - :py:meth:`ProcessBuilder.round() <openeo.processes.ProcessBuilder.round>`, :py:meth:`round() <openeo.processes.round>`
     *   - `run_udf <https://processes.openeo.org/#run_udf>`_
-        - :py:meth:`VectorCube.run_udf() <openeo.rest.vectorcube.VectorCube.run_udf>`
+        - :py:meth:`ProcessBuilder.run_udf() <openeo.processes.ProcessBuilder.run_udf>`, :py:meth:`run_udf() <openeo.processes.run_udf>`, :py:meth:`VectorCube.run_udf() <openeo.rest.vectorcube.VectorCube.run_udf>`
+    *   - `run_udf_externally <https://processes.openeo.org/#run_udf_externally>`_
+        - :py:meth:`ProcessBuilder.run_udf_externally() <openeo.processes.ProcessBuilder.run_udf_externally>`, :py:meth:`run_udf_externally() <openeo.processes.run_udf_externally>`
     *   - `sar_backscatter <https://processes.openeo.org/#sar_backscatter>`_
-        - :py:meth:`DataCube.sar_backscatter() <openeo.rest.datacube.DataCube.sar_backscatter>`
+        - :py:meth:`ProcessBuilder.sar_backscatter() <openeo.processes.ProcessBuilder.sar_backscatter>`, :py:meth:`sar_backscatter() <openeo.processes.sar_backscatter>`, :py:meth:`DataCube.sar_backscatter() <openeo.rest.datacube.DataCube.sar_backscatter>`
+    *   - `save_ml_model <https://processes.openeo.org/#save_ml_model>`_
+        - :py:meth:`ProcessBuilder.save_ml_model() <openeo.processes.ProcessBuilder.save_ml_model>`, :py:meth:`save_ml_model() <openeo.processes.save_ml_model>`
     *   - `save_result <https://processes.openeo.org/#save_result>`_
-        - :py:meth:`VectorCube.save_result() <openeo.rest.vectorcube.VectorCube.save_result>`, :py:meth:`DataCube.save_result() <openeo.rest.datacube.DataCube.save_result>`
+        - :py:meth:`ProcessBuilder.save_result() <openeo.processes.ProcessBuilder.save_result>`, :py:meth:`save_result() <openeo.processes.save_result>`, :py:meth:`VectorCube.save_result() <openeo.rest.vectorcube.VectorCube.save_result>`, :py:meth:`DataCube.save_result() <openeo.rest.datacube.DataCube.save_result>`
+    *   - `sd <https://processes.openeo.org/#sd>`_
+        - :py:meth:`ProcessBuilder.sd() <openeo.processes.ProcessBuilder.sd>`, :py:meth:`sd() <openeo.processes.sd>`
+    *   - `sgn <https://processes.openeo.org/#sgn>`_
+        - :py:meth:`ProcessBuilder.sgn() <openeo.processes.ProcessBuilder.sgn>`, :py:meth:`sgn() <openeo.processes.sgn>`
+    *   - `sin <https://processes.openeo.org/#sin>`_
+        - :py:meth:`ProcessBuilder.sin() <openeo.processes.ProcessBuilder.sin>`, :py:meth:`sin() <openeo.processes.sin>`
+    *   - `sinh <https://processes.openeo.org/#sinh>`_
+        - :py:meth:`ProcessBuilder.sinh() <openeo.processes.ProcessBuilder.sinh>`, :py:meth:`sinh() <openeo.processes.sinh>`
+    *   - `sort <https://processes.openeo.org/#sort>`_
+        - :py:meth:`ProcessBuilder.sort() <openeo.processes.ProcessBuilder.sort>`, :py:meth:`sort() <openeo.processes.sort>`
+    *   - `sqrt <https://processes.openeo.org/#sqrt>`_
+        - :py:meth:`ProcessBuilder.sqrt() <openeo.processes.ProcessBuilder.sqrt>`, :py:meth:`sqrt() <openeo.processes.sqrt>`
     *   - `subtract <https://processes.openeo.org/#subtract>`_
-        - :py:meth:`DataCube.subtract() <openeo.rest.datacube.DataCube.subtract>`, :py:meth:`DataCube.__sub__() <openeo.rest.datacube.DataCube.__sub__>`, :py:meth:`DataCube.__rsub__() <openeo.rest.datacube.DataCube.__rsub__>`
+        - :py:meth:`ProcessBuilder.__sub__() <openeo.processes.ProcessBuilder.__sub__>`, :py:meth:`ProcessBuilder.__rsub__() <openeo.processes.ProcessBuilder.__rsub__>`, :py:meth:`ProcessBuilder.subtract() <openeo.processes.ProcessBuilder.subtract>`, :py:meth:`subtract() <openeo.processes.subtract>`, :py:meth:`DataCube.subtract() <openeo.rest.datacube.DataCube.subtract>`, :py:meth:`DataCube.__sub__() <openeo.rest.datacube.DataCube.__sub__>`, :py:meth:`DataCube.__rsub__() <openeo.rest.datacube.DataCube.__rsub__>`
+    *   - `sum <https://processes.openeo.org/#sum>`_
+        - :py:meth:`ProcessBuilder.sum() <openeo.processes.ProcessBuilder.sum>`, :py:meth:`sum() <openeo.processes.sum>`
+    *   - `tan <https://processes.openeo.org/#tan>`_
+        - :py:meth:`ProcessBuilder.tan() <openeo.processes.ProcessBuilder.tan>`, :py:meth:`tan() <openeo.processes.tan>`
+    *   - `tanh <https://processes.openeo.org/#tanh>`_
+        - :py:meth:`ProcessBuilder.tanh() <openeo.processes.ProcessBuilder.tanh>`, :py:meth:`tanh() <openeo.processes.tanh>`
+    *   - `text_begins <https://processes.openeo.org/#text_begins>`_
+        - :py:meth:`ProcessBuilder.text_begins() <openeo.processes.ProcessBuilder.text_begins>`, :py:meth:`text_begins() <openeo.processes.text_begins>`
+    *   - `text_concat <https://processes.openeo.org/#text_concat>`_
+        - :py:meth:`ProcessBuilder.text_concat() <openeo.processes.ProcessBuilder.text_concat>`, :py:meth:`text_concat() <openeo.processes.text_concat>`
+    *   - `text_contains <https://processes.openeo.org/#text_contains>`_
+        - :py:meth:`ProcessBuilder.text_contains() <openeo.processes.ProcessBuilder.text_contains>`, :py:meth:`text_contains() <openeo.processes.text_contains>`
+    *   - `text_ends <https://processes.openeo.org/#text_ends>`_
+        - :py:meth:`ProcessBuilder.text_ends() <openeo.processes.ProcessBuilder.text_ends>`, :py:meth:`text_ends() <openeo.processes.text_ends>`
+    *   - `trim_cube <https://processes.openeo.org/#trim_cube>`_
+        - :py:meth:`ProcessBuilder.trim_cube() <openeo.processes.ProcessBuilder.trim_cube>`, :py:meth:`trim_cube() <openeo.processes.trim_cube>`
     *   - `unflatten_dimension <https://processes.openeo.org/#unflatten_dimension>`_
-        - :py:meth:`DataCube.unflatten_dimension() <openeo.rest.datacube.DataCube.unflatten_dimension>`
+        - :py:meth:`ProcessBuilder.unflatten_dimension() <openeo.processes.ProcessBuilder.unflatten_dimension>`, :py:meth:`unflatten_dimension() <openeo.processes.unflatten_dimension>`, :py:meth:`DataCube.unflatten_dimension() <openeo.rest.datacube.DataCube.unflatten_dimension>`
+    *   - `variance <https://processes.openeo.org/#variance>`_
+        - :py:meth:`ProcessBuilder.variance() <openeo.processes.ProcessBuilder.variance>`, :py:meth:`variance() <openeo.processes.variance>`
+    *   - `vector_buffer <https://processes.openeo.org/#vector_buffer>`_
+        - :py:meth:`ProcessBuilder.vector_buffer() <openeo.processes.ProcessBuilder.vector_buffer>`, :py:meth:`vector_buffer() <openeo.processes.vector_buffer>`
+    *   - `vector_to_random_points <https://processes.openeo.org/#vector_to_random_points>`_
+        - :py:meth:`ProcessBuilder.vector_to_random_points() <openeo.processes.ProcessBuilder.vector_to_random_points>`, :py:meth:`vector_to_random_points() <openeo.processes.vector_to_random_points>`
+    *   - `vector_to_regular_points <https://processes.openeo.org/#vector_to_regular_points>`_
+        - :py:meth:`ProcessBuilder.vector_to_regular_points() <openeo.processes.ProcessBuilder.vector_to_regular_points>`, :py:meth:`vector_to_regular_points() <openeo.processes.vector_to_regular_points>`
+    *   - `xor <https://processes.openeo.org/#xor>`_
+        - :py:meth:`ProcessBuilder.xor() <openeo.processes.ProcessBuilder.xor>`, :py:meth:`xor() <openeo.processes.xor>`
 
 :subscript:`(Table autogenerated on 2023-03-15)`
diff --git a/docs/processes.rst b/docs/processes.rst
index 60b1651e5..4aeeb8a89 100644
--- a/docs/processes.rst
+++ b/docs/processes.rst
@@ -227,20 +227,37 @@ to be invoked on a subset or slice of the datacube.
 For example:
 
 *   process ``apply`` requires a transformation that will be applied
-    to each pixel in the cube (separately)
+    to each pixel in the cube (separately), e.g. in pseudocode
+
+    .. code-block:: text
+
+        cube.apply(
+            given a pixel value
+            => scale it with factor 0.01
+        )
+
 *   process ``reduce_dimension`` requires an aggregation function to convert
-    an array of pixel values (along a given dimension) to a single value
+    an array of pixel values (along a given dimension) to a single value,
+    e.g. in pseudocode
+
+    .. code-block:: text
+
+        cube.reduce_dimension(
+            given a pixel timeseries (array) for a (x,y)-location
+            => temporal mean of that array
+        )
+
 *   process ``aggregate_spatial`` requires a function to aggregate the values
     in one or more geometries
 
 These transformation functions are usually called "**callbacks**"
 because instead of being called explicitly by the user,
-they are called by their "parent" process
+they are called and managed by their "parent" process
 (the ``apply``, ``reduce_dimension`` and ``aggregate_spatial`` in the examples)
 
 
 The openEO Python Client Library currently provides a couple of DataCube methods
-that expect a callback, most commonly:
+that expect such a callback, most commonly:
 
 - :py:meth:`openeo.rest.datacube.DataCube.aggregate_spatial`
 - :py:meth:`openeo.rest.datacube.DataCube.aggregate_temporal`
@@ -249,8 +266,14 @@ that expect a callback, most commonly:
 - :py:meth:`openeo.rest.datacube.DataCube.apply_neighborhood`
 - :py:meth:`openeo.rest.datacube.DataCube.reduce_dimension`
 
-These functions support several ways to specify the desired callback.
+The openEO Python Client Library supports several ways
+to specify the desired callback for these functions:
+
 
+.. contents::
+   :depth: 1
+   :local:
+   :backlinks: top
 
 Callback as string
 ------------------
@@ -269,7 +292,7 @@ for example:
 This approach is only possible if the desired transformation is available
 as a single process. If not, use one of the methods below.
 
-Also important is that the "signature" of the provided callback process
+It's also important to note that the "signature" of the provided callback process
 should correspond properly with what the parent process expects.
 For example: ``apply`` requires a callback process that receives a
 number and returns one (like ``absolute`` or ``sqrt``),
@@ -283,44 +306,41 @@ Callback as a callable
 -----------------------
 
 You can also specify the callback as a "callable":
-a Python object that can be called (e.g. a function without parenthesis).
+which is a fancy word for a Python object that can be called,
+but just think of it like a function you can call.
 
-The openEO Python Client Library defines the
-official processes in the :py:mod:`openeo.processes` module,
-which can be used directly:
+You can use a regular Python function, like this:
 
 .. code-block:: python
 
-    from openeo.processes import absolute, max
+    def transform(x):
+        return x * 2 + 3
 
-    cube.apply(absolute)
-    cube.reduce_dimension(max, dimension="t")
+    cube.apply(transform)
 
-You can also use ``lambda`` functions:
+or, more compactly, a "lambda"
+(a construct in Python to create anonymous inline functions):
 
 .. code-block:: python
 
     cube.apply(lambda x: x * 2 + 3)
 
 
-or normal Python functions:
+The openEO Python Client Library implements most of the official openEO processes as
+:ref:`functions in the "openeo.processes" module <openeo_processes_functions>`,
+which can be used directly as callback:
 
 .. code-block:: python
 
-    from openeo.processes import array_element
-
-    def my_bandmath(data):
-        band1 = array_element(data, index=0)
-        band2 = array_element(data, index=1)
-        return band1 + 1.2 * band2
-
+    from openeo.processes import absolute, max
 
-    cube.reduce_dimension(my_bandmath, dimension="bands")
+    cube.apply(absolute)
+    cube.reduce_dimension(max, dimension="t")
 
 
-The argument that is passed to these functions is
-an instance of :py:class:`openeo.processes.ProcessBuilder`.
-This is a helper object with predefined methods for all standard processes,
+The argument that will be passed to all these callback functions is
+a :py:class:`ProcessBuilder <openeo.processes.ProcessBuilder>` instance.
+This is a helper object with predefined methods for all standard openEO processes,
 allowing to use an object oriented coding style to define the callback.
 For example:
 
@@ -334,12 +354,14 @@ For example:
     cube.reduce_dimension(avg, dimension="t")
 
 
-These methods also return ``ProcessBuilder`` objects,
+These methods also return :py:class:`ProcessBuilder <openeo.processes.ProcessBuilder>` objects,
 which also allows writing callbacks in chained fashion:
 
 .. code-block:: python
 
-    cube.apply(lambda x: x.absolute().cos().add(y=1.23))
+    cube.apply(
+        lambda x: x.absolute().cos().add(y=1.23)
+    )
 
 
 All this gives a lot of flexibility to define callbacks compactly
@@ -377,7 +399,7 @@ looks intuitive and straightforward, but it should be noted
 that not everything is allowed in these functions.
 You should just limit yourself to calling
 :py:mod:`openeo.processes` functions,
-:py:class:`openeo.processes.ProcessBuilder` methods
+:py:class:`ProcessBuilder <openeo.processes.ProcessBuilder>` methods
 and basic math operators.
 Don't call functions from other libraries like numpy or scipy.
 Don't use Python control flow statements like ``if/else`` constructs
@@ -414,9 +436,14 @@ Callback as ``PGNode``
 -----------------------
 
 You can also pass a :py:class:`~openeo.internal.graph_building.PGNode` object as callback.
-This method is used internally and could be useful for more
-advanced use cases, but it requires more in-depth knowledge of
-the openEO API and openEO Python Client Library to construct correctly.
+
+.. attention::
+    This approach should generally not be used in normal use cases.
+    The other options discussed above should be preferred.
+    It's mainly intended for internal use and an occasional, advanced use case.
+    It requires in-depth knowledge of the openEO API
+    and openEO Python Client Library to construct correctly.
+
 Some examples:
 
 .. code-block:: python
diff --git a/openeo/internal/processes/generator.py b/openeo/internal/processes/generator.py
index 112871bf4..b13eaa757 100644
--- a/openeo/internal/processes/generator.py
+++ b/openeo/internal/processes/generator.py
@@ -4,7 +4,7 @@
 import sys
 import textwrap
 from pathlib import Path
-from typing import Union, List, Iterator
+from typing import Union, List, Iterator, Optional
 
 from openeo.internal.processes.parse import Process, parse_all_from_dir
 
@@ -14,18 +14,20 @@ class PythonRenderer:
     DEFAULT_WIDTH = 115
 
     def __init__(
-            self,
-            oo_mode=False,
-            indent="    ",
-            body_template="return _process({id!r}, {args})",
-            optional_default="None",
-            return_type_hint: str = None
+        self,
+        oo_mode: bool = False,
+        indent: str = "    ",
+        body_template: str = "return _process({id!r}, {args})",
+        optional_default="None",
+        return_type_hint: Optional[str] = None,
+        decorator: Optional[str] = None,
     ):
         self.oo_mode = oo_mode
         self.indent = indent
         self.body_template = body_template
         self.optional_default = optional_default
         self.return_type_hint = return_type_hint
+        self.decorator = decorator
 
     def render_process(self, process: Process, prefix: str = None, width: int = DEFAULT_WIDTH) -> str:
         if prefix is None:
@@ -46,11 +48,12 @@ def render_process(self, process: Process, prefix: str = None, width: int = DEFA
             id=process.id, safe_name=self._safe_name(process.id), args=call_args
         )
 
-        return textwrap.indent("\n".join([
+        lines = ([self.decorator] if self.decorator else []) + [
             def_line,
             self.render_docstring(process, width=width - len(prefix), prefix=self.indent),
             body
-        ]), prefix=prefix)
+        ]
+        return textwrap.indent("\n".join(lines), prefix=prefix)
 
     def _safe_name(self, name: str) -> str:
         if keyword.iskeyword(name):
@@ -107,45 +110,61 @@ def collect_processes(sources: List[Union[Path, str]]) -> List[Process]:
 
 
 def generate_process_py(processes: List[Process], output=sys.stdout, argv=None):
-    oo_src = textwrap.dedent("""
+    oo_src = textwrap.dedent(
+        """
         import builtins
         from openeo.internal.processes.builder import ProcessBuilderBase, UNSET
+        from openeo.internal.documentation import openeo_process
 
 
         class ProcessBuilder(ProcessBuilderBase):
+            \"\"\"
+            .. include:: api-processbuilder.rst
+            \"\"\"
 
             _ITERATION_LIMIT = 100
 
+            @openeo_process(process_id="add", mode="operator")
             def __add__(self, other) -> 'ProcessBuilder':
                 return self.add(other)
 
+            @openeo_process(process_id="add", mode="operator")
             def __radd__(self, other) -> 'ProcessBuilder':
                 return add(other, self)
 
+            @openeo_process(process_id="subtract", mode="operator")
             def __sub__(self, other) -> 'ProcessBuilder':
                 return self.subtract(other)
 
+            @openeo_process(process_id="subtract", mode="operator")
             def __rsub__(self, other) -> 'ProcessBuilder':
                 return subtract(other, self)
 
+            @openeo_process(process_id="multiply", mode="operator")
             def __mul__(self, other) -> 'ProcessBuilder':
                 return self.multiply(other)
 
+            @openeo_process(process_id="multiply", mode="operator")
             def __rmul__(self, other) -> 'ProcessBuilder':
                 return multiply(other, self)
 
+            @openeo_process(process_id="divide", mode="operator")
             def __truediv__(self, other) -> 'ProcessBuilder':
                 return self.divide(other)
 
+            @openeo_process(process_id="divide", mode="operator")
             def __rtruediv__(self, other) -> 'ProcessBuilder':
                 return divide(other, self)
 
+            @openeo_process(process_id="multiply", mode="operator")
             def __neg__(self) -> 'ProcessBuilder':
                 return self.multiply(-1)
 
+            @openeo_process(process_id="power", mode="operator")
             def __pow__(self, other) -> 'ProcessBuilder':
                 return self.power(other)
 
+            @openeo_process(process_id="array_element", mode="operator")
             def __getitem__(self, key) -> 'ProcessBuilder':
                 if isinstance(key, builtins.int):
                     if key > self._ITERATION_LIMIT:
@@ -158,43 +177,54 @@ def __getitem__(self, key) -> 'ProcessBuilder':
                 else:
                     return self.array_element(label=key)
 
+            @openeo_process(process_id="eq", mode="operator")
             def __eq__(self, other) -> 'ProcessBuilder':
                 return eq(self, other)
 
+            @openeo_process(process_id="neq", mode="operator")
             def __ne__(self, other) -> 'ProcessBuilder':
                 return neq(self, other)
 
+            @openeo_process(process_id="lt", mode="operator")
             def __lt__(self, other) -> 'ProcessBuilder':
                 return lt(self, other)
 
+            @openeo_process(process_id="lte", mode="operator")
             def __le__(self, other) -> 'ProcessBuilder':
                 return lte(self, other)
 
+            @openeo_process(process_id="ge", mode="operator")
             def __ge__(self, other) -> 'ProcessBuilder':
                 return gte(self, other)
 
+            @openeo_process(process_id="gt", mode="operator")
             def __gt__(self, other) -> 'ProcessBuilder':
                 return gt(self, other)
 
-    """)
-    fun_src = textwrap.dedent("""
+    """
+    )
+    fun_src = textwrap.dedent(
+        """
         # Public shortcut
         process = ProcessBuilder.process
         # Private shortcut that has lower chance to collide with a process argument named `process`
         _process = ProcessBuilder.process
 
 
-    """)
+    """
+    )
     fun_renderer = PythonRenderer(
         body_template="return _process({id!r}, {args})",
         optional_default="UNSET",
-        return_type_hint="ProcessBuilder"
+        return_type_hint="ProcessBuilder",
+        decorator="@openeo_process",
     )
     oo_renderer = PythonRenderer(
         oo_mode=True,
         body_template="return {safe_name}({args})",
         optional_default="UNSET",
-        return_type_hint="'ProcessBuilder'"
+        return_type_hint="'ProcessBuilder'",
+        decorator="@openeo_process",
     )
     for p in processes:
         fun_src += fun_renderer.render_process(p) + "\n\n\n"
diff --git a/openeo/processes.py b/openeo/processes.py
index 880f182f3..517f2ab4c 100644
--- a/openeo/processes.py
+++ b/openeo/processes.py
@@ -7,42 +7,57 @@
 
 import builtins
 from openeo.internal.processes.builder import ProcessBuilderBase, UNSET
+from openeo.internal.documentation import openeo_process
 
 
 class ProcessBuilder(ProcessBuilderBase):
+    """
+    .. include:: api-processbuilder.rst
+    """
 
     _ITERATION_LIMIT = 100
 
+    @openeo_process(process_id="add", mode="operator")
     def __add__(self, other) -> 'ProcessBuilder':
         return self.add(other)
 
+    @openeo_process(process_id="add", mode="operator")
     def __radd__(self, other) -> 'ProcessBuilder':
         return add(other, self)
 
+    @openeo_process(process_id="subtract", mode="operator")
     def __sub__(self, other) -> 'ProcessBuilder':
         return self.subtract(other)
 
+    @openeo_process(process_id="subtract", mode="operator")
     def __rsub__(self, other) -> 'ProcessBuilder':
         return subtract(other, self)
 
+    @openeo_process(process_id="multiply", mode="operator")
     def __mul__(self, other) -> 'ProcessBuilder':
         return self.multiply(other)
 
+    @openeo_process(process_id="multiply", mode="operator")
     def __rmul__(self, other) -> 'ProcessBuilder':
         return multiply(other, self)
 
+    @openeo_process(process_id="divide", mode="operator")
     def __truediv__(self, other) -> 'ProcessBuilder':
         return self.divide(other)
 
+    @openeo_process(process_id="divide", mode="operator")
     def __rtruediv__(self, other) -> 'ProcessBuilder':
         return divide(other, self)
 
+    @openeo_process(process_id="multiply", mode="operator")
     def __neg__(self) -> 'ProcessBuilder':
         return self.multiply(-1)
 
+    @openeo_process(process_id="power", mode="operator")
     def __pow__(self, other) -> 'ProcessBuilder':
         return self.power(other)
 
+    @openeo_process(process_id="array_element", mode="operator")
     def __getitem__(self, key) -> 'ProcessBuilder':
         if isinstance(key, builtins.int):
             if key > self._ITERATION_LIMIT:
@@ -55,24 +70,31 @@ def __getitem__(self, key) -> 'ProcessBuilder':
         else:
             return self.array_element(label=key)
 
+    @openeo_process(process_id="eq", mode="operator")
     def __eq__(self, other) -> 'ProcessBuilder':
         return eq(self, other)
 
+    @openeo_process(process_id="neq", mode="operator")
     def __ne__(self, other) -> 'ProcessBuilder':
         return neq(self, other)
 
+    @openeo_process(process_id="lt", mode="operator")
     def __lt__(self, other) -> 'ProcessBuilder':
         return lt(self, other)
 
+    @openeo_process(process_id="lte", mode="operator")
     def __le__(self, other) -> 'ProcessBuilder':
         return lte(self, other)
 
+    @openeo_process(process_id="ge", mode="operator")
     def __ge__(self, other) -> 'ProcessBuilder':
         return gte(self, other)
 
+    @openeo_process(process_id="gt", mode="operator")
     def __gt__(self, other) -> 'ProcessBuilder':
         return gt(self, other)
 
+    @openeo_process
     def absolute(self) -> 'ProcessBuilder':
         """
         Absolute value
@@ -83,6 +105,7 @@ def absolute(self) -> 'ProcessBuilder':
         """
         return absolute(x=self)
 
+    @openeo_process
     def add(self, y) -> 'ProcessBuilder':
         """
         Addition of two numbers
@@ -94,6 +117,7 @@ def add(self, y) -> 'ProcessBuilder':
         """
         return add(x=self, y=y)
 
+    @openeo_process
     def add_dimension(self, name, label, type=UNSET) -> 'ProcessBuilder':
         """
         Add a new dimension
@@ -108,6 +132,7 @@ def add_dimension(self, name, label, type=UNSET) -> 'ProcessBuilder':
         """
         return add_dimension(data=self, name=name, label=label, type=type)
 
+    @openeo_process
     def aggregate_spatial(self, geometries, reducer, target_dimension=UNSET, context=UNSET) -> 'ProcessBuilder':
         """
         Zonal statistics for geometries
@@ -148,6 +173,7 @@ def aggregate_spatial(self, geometries, reducer, target_dimension=UNSET, context
         """
         return aggregate_spatial(data=self, geometries=geometries, reducer=reducer, target_dimension=target_dimension, context=context)
 
+    @openeo_process
     def aggregate_spatial_window(self, reducer, size, boundary=UNSET, align=UNSET, context=UNSET) -> 'ProcessBuilder':
         """
         Zonal statistics for rectangular windows
@@ -176,6 +202,7 @@ def aggregate_spatial_window(self, reducer, size, boundary=UNSET, align=UNSET, c
         """
         return aggregate_spatial_window(data=self, reducer=reducer, size=size, boundary=boundary, align=align, context=context)
 
+    @openeo_process
     def aggregate_temporal(self, intervals, reducer, labels=UNSET, dimension=UNSET, context=UNSET) -> 'ProcessBuilder':
         """
         Temporal aggregations
@@ -209,6 +236,7 @@ def aggregate_temporal(self, intervals, reducer, labels=UNSET, dimension=UNSET,
         """
         return aggregate_temporal(data=self, intervals=intervals, reducer=reducer, labels=labels, dimension=dimension, context=context)
 
+    @openeo_process
     def aggregate_temporal_period(self, period, reducer, dimension=UNSET, context=UNSET) -> 'ProcessBuilder':
         """
         Temporal aggregations based on calendar hierarchies
@@ -253,6 +281,7 @@ def aggregate_temporal_period(self, period, reducer, dimension=UNSET, context=UN
         """
         return aggregate_temporal_period(data=self, period=period, reducer=reducer, dimension=dimension, context=context)
 
+    @openeo_process
     def all(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Are all of the values true?
@@ -264,6 +293,7 @@ def all(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return all(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def and_(self, y) -> 'ProcessBuilder':
         """
         Logical AND
@@ -275,6 +305,7 @@ def and_(self, y) -> 'ProcessBuilder':
         """
         return and_(x=self, y=y)
 
+    @openeo_process
     def anomaly(self, normals, period) -> 'ProcessBuilder':
         """
         Compute anomalies
@@ -314,6 +345,7 @@ def anomaly(self, normals, period) -> 'ProcessBuilder':
         """
         return anomaly(data=self, normals=normals, period=period)
 
+    @openeo_process
     def any(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Is at least one value true?
@@ -325,6 +357,7 @@ def any(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return any(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def apply(self, process, context=UNSET) -> 'ProcessBuilder':
         """
         Apply a process to each pixel
@@ -340,6 +373,7 @@ def apply(self, process, context=UNSET) -> 'ProcessBuilder':
         """
         return apply(data=self, process=process, context=context)
 
+    @openeo_process
     def apply_dimension(self, process, dimension, target_dimension=UNSET, context=UNSET) -> 'ProcessBuilder':
         """
         Apply a process to pixels along a dimension
@@ -376,6 +410,7 @@ def apply_dimension(self, process, dimension, target_dimension=UNSET, context=UN
         """
         return apply_dimension(data=self, process=process, dimension=dimension, target_dimension=target_dimension, context=context)
 
+    @openeo_process
     def apply_kernel(self, kernel, factor=UNSET, border=UNSET, replace_invalid=UNSET) -> 'ProcessBuilder':
         """
         Apply a spatial convolution with a kernel
@@ -402,6 +437,7 @@ def apply_kernel(self, kernel, factor=UNSET, border=UNSET, replace_invalid=UNSET
         """
         return apply_kernel(data=self, kernel=kernel, factor=factor, border=border, replace_invalid=replace_invalid)
 
+    @openeo_process
     def apply_neighborhood(self, process, size, overlap=UNSET, context=UNSET) -> 'ProcessBuilder':
         """
         Apply a process to pixels in a n-dimensional neighborhood
@@ -425,6 +461,7 @@ def apply_neighborhood(self, process, size, overlap=UNSET, context=UNSET) -> 'Pr
         """
         return apply_neighborhood(data=self, process=process, size=size, overlap=overlap, context=context)
 
+    @openeo_process
     def arccos(self) -> 'ProcessBuilder':
         """
         Inverse cosine
@@ -435,6 +472,7 @@ def arccos(self) -> 'ProcessBuilder':
         """
         return arccos(x=self)
 
+    @openeo_process
     def arcosh(self) -> 'ProcessBuilder':
         """
         Inverse hyperbolic cosine
@@ -445,6 +483,7 @@ def arcosh(self) -> 'ProcessBuilder':
         """
         return arcosh(x=self)
 
+    @openeo_process
     def arcsin(self) -> 'ProcessBuilder':
         """
         Inverse sine
@@ -455,6 +494,7 @@ def arcsin(self) -> 'ProcessBuilder':
         """
         return arcsin(x=self)
 
+    @openeo_process
     def arctan(self) -> 'ProcessBuilder':
         """
         Inverse tangent
@@ -465,6 +505,7 @@ def arctan(self) -> 'ProcessBuilder':
         """
         return arctan(x=self)
 
+    @openeo_process
     def arctan2(self, x) -> 'ProcessBuilder':
         """
         Inverse tangent of two numbers
@@ -476,6 +517,7 @@ def arctan2(self, x) -> 'ProcessBuilder':
         """
         return arctan2(y=self, x=x)
 
+    @openeo_process
     def ard_normalized_radar_backscatter(self, elevation_model=UNSET, contributing_area=UNSET, ellipsoid_incidence_angle=UNSET, noise_removal=UNSET, options=UNSET) -> 'ProcessBuilder':
         """
         CARD4L compliant SAR NRB generation
@@ -501,6 +543,7 @@ def ard_normalized_radar_backscatter(self, elevation_model=UNSET, contributing_a
         """
         return ard_normalized_radar_backscatter(data=self, elevation_model=elevation_model, contributing_area=contributing_area, ellipsoid_incidence_angle=ellipsoid_incidence_angle, noise_removal=noise_removal, options=options)
 
+    @openeo_process
     def ard_surface_reflectance(self, atmospheric_correction_method, cloud_detection_method, elevation_model=UNSET, atmospheric_correction_options=UNSET, cloud_detection_options=UNSET) -> 'ProcessBuilder':
         """
         CARD4L compliant Surface Reflectance generation
@@ -548,6 +591,7 @@ def ard_surface_reflectance(self, atmospheric_correction_method, cloud_detection
         """
         return ard_surface_reflectance(data=self, atmospheric_correction_method=atmospheric_correction_method, cloud_detection_method=cloud_detection_method, elevation_model=elevation_model, atmospheric_correction_options=atmospheric_correction_options, cloud_detection_options=cloud_detection_options)
 
+    @openeo_process
     def array_append(self, value, label=UNSET) -> 'ProcessBuilder':
         """
         Append a value to an array
@@ -562,6 +606,7 @@ def array_append(self, value, label=UNSET) -> 'ProcessBuilder':
         """
         return array_append(data=self, value=value, label=label)
 
+    @openeo_process
     def array_apply(self, process, context=UNSET) -> 'ProcessBuilder':
         """
         Apply a process to each array element
@@ -577,6 +622,7 @@ def array_apply(self, process, context=UNSET) -> 'ProcessBuilder':
         """
         return array_apply(data=self, process=process, context=context)
 
+    @openeo_process
     def array_concat(self, array2) -> 'ProcessBuilder':
         """
         Merge two arrays
@@ -588,6 +634,7 @@ def array_concat(self, array2) -> 'ProcessBuilder':
         """
         return array_concat(array1=self, array2=array2)
 
+    @openeo_process
     def array_contains(self, value) -> 'ProcessBuilder':
         """
         Check whether the array contains a given value
@@ -599,6 +646,7 @@ def array_contains(self, value) -> 'ProcessBuilder':
         """
         return array_contains(data=self, value=value)
 
+    @openeo_process
     def array_create(self=UNSET, repeat=UNSET) -> 'ProcessBuilder':
         """
         Create an array
@@ -611,6 +659,7 @@ def array_create(self=UNSET, repeat=UNSET) -> 'ProcessBuilder':
         """
         return array_create(data=self, repeat=repeat)
 
+    @openeo_process
     def array_create_labeled(self, labels) -> 'ProcessBuilder':
         """
         Create a labeled array
@@ -622,6 +671,7 @@ def array_create_labeled(self, labels) -> 'ProcessBuilder':
         """
         return array_create_labeled(data=self, labels=labels)
 
+    @openeo_process
     def array_element(self, index=UNSET, label=UNSET, return_nodata=UNSET) -> 'ProcessBuilder':
         """
         Get an element from an array
@@ -637,6 +687,7 @@ def array_element(self, index=UNSET, label=UNSET, return_nodata=UNSET) -> 'Proce
         """
         return array_element(data=self, index=index, label=label, return_nodata=return_nodata)
 
+    @openeo_process
     def array_filter(self, condition, context=UNSET) -> 'ProcessBuilder':
         """
         Filter an array based on a condition
@@ -651,6 +702,7 @@ def array_filter(self, condition, context=UNSET) -> 'ProcessBuilder':
         """
         return array_filter(data=self, condition=condition, context=context)
 
+    @openeo_process
     def array_find(self, value, reverse=UNSET) -> 'ProcessBuilder':
         """
         Get the index for a value in an array
@@ -665,6 +717,7 @@ def array_find(self, value, reverse=UNSET) -> 'ProcessBuilder':
         """
         return array_find(data=self, value=value, reverse=reverse)
 
+    @openeo_process
     def array_find_label(self, label) -> 'ProcessBuilder':
         """
         Get the index for a label in a labeled array
@@ -677,6 +730,7 @@ def array_find_label(self, label) -> 'ProcessBuilder':
         """
         return array_find_label(data=self, label=label)
 
+    @openeo_process
     def array_interpolate_linear(self) -> 'ProcessBuilder':
         """
         One-dimensional linear interpolation for arrays
@@ -690,6 +744,7 @@ def array_interpolate_linear(self) -> 'ProcessBuilder':
         """
         return array_interpolate_linear(data=self)
 
+    @openeo_process
     def array_labels(self) -> 'ProcessBuilder':
         """
         Get the labels for an array
@@ -700,6 +755,7 @@ def array_labels(self) -> 'ProcessBuilder':
         """
         return array_labels(data=self)
 
+    @openeo_process
     def array_modify(self, values, index, length=UNSET) -> 'ProcessBuilder':
         """
         Change the content of an array (remove, insert, update)
@@ -720,6 +776,7 @@ def array_modify(self, values, index, length=UNSET) -> 'ProcessBuilder':
         """
         return array_modify(data=self, values=values, index=index, length=length)
 
+    @openeo_process
     def arsinh(self) -> 'ProcessBuilder':
         """
         Inverse hyperbolic sine
@@ -730,6 +787,7 @@ def arsinh(self) -> 'ProcessBuilder':
         """
         return arsinh(x=self)
 
+    @openeo_process
     def artanh(self) -> 'ProcessBuilder':
         """
         Inverse hyperbolic tangent
@@ -740,6 +798,7 @@ def artanh(self) -> 'ProcessBuilder':
         """
         return artanh(x=self)
 
+    @openeo_process
     def atmospheric_correction(self, method, elevation_model=UNSET, options=UNSET) -> 'ProcessBuilder':
         """
         Apply atmospheric correction
@@ -758,6 +817,7 @@ def atmospheric_correction(self, method, elevation_model=UNSET, options=UNSET) -
         """
         return atmospheric_correction(data=self, method=method, elevation_model=elevation_model, options=options)
 
+    @openeo_process
     def between(self, min, max, exclude_max=UNSET) -> 'ProcessBuilder':
         """
         Between comparison
@@ -771,6 +831,7 @@ def between(self, min, max, exclude_max=UNSET) -> 'ProcessBuilder':
         """
         return between(x=self, min=min, max=max, exclude_max=exclude_max)
 
+    @openeo_process
     def ceil(self) -> 'ProcessBuilder':
         """
         Round fractions up
@@ -781,6 +842,7 @@ def ceil(self) -> 'ProcessBuilder':
         """
         return ceil(x=self)
 
+    @openeo_process
     def climatological_normal(self, period, climatology_period=UNSET) -> 'ProcessBuilder':
         """
         Compute climatology normals
@@ -811,6 +873,7 @@ def climatological_normal(self, period, climatology_period=UNSET) -> 'ProcessBui
         """
         return climatological_normal(data=self, period=period, climatology_period=climatology_period)
 
+    @openeo_process
     def clip(self, min, max) -> 'ProcessBuilder':
         """
         Clip a value between a minimum and a maximum
@@ -825,6 +888,7 @@ def clip(self, min, max) -> 'ProcessBuilder':
         """
         return clip(x=self, min=min, max=max)
 
+    @openeo_process
     def cloud_detection(self, method, options=UNSET) -> 'ProcessBuilder':
         """
         Create cloud masks
@@ -844,6 +908,7 @@ def cloud_detection(self, method, options=UNSET) -> 'ProcessBuilder':
         """
         return cloud_detection(data=self, method=method, options=options)
 
+    @openeo_process
     def constant(self) -> 'ProcessBuilder':
         """
         Define a constant value
@@ -854,6 +919,7 @@ def constant(self) -> 'ProcessBuilder':
         """
         return constant(x=self)
 
+    @openeo_process
     def cos(self) -> 'ProcessBuilder':
         """
         Cosine
@@ -864,6 +930,7 @@ def cos(self) -> 'ProcessBuilder':
         """
         return cos(x=self)
 
+    @openeo_process
     def cosh(self) -> 'ProcessBuilder':
         """
         Hyperbolic cosine
@@ -874,6 +941,7 @@ def cosh(self) -> 'ProcessBuilder':
         """
         return cosh(x=self)
 
+    @openeo_process
     def count(self, condition=UNSET, context=UNSET) -> 'ProcessBuilder':
         """
         Count the number of elements
@@ -889,6 +957,7 @@ def count(self, condition=UNSET, context=UNSET) -> 'ProcessBuilder':
         """
         return count(data=self, condition=condition, context=context)
 
+    @openeo_process
     def create_raster_cube(self) -> 'ProcessBuilder':
         """
         Create an empty raster data cube
@@ -897,6 +966,7 @@ def create_raster_cube(self) -> 'ProcessBuilder':
         """
         return create_raster_cube()
 
+    @openeo_process
     def cummax(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Cumulative maxima
@@ -910,6 +980,7 @@ def cummax(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return cummax(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def cummin(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Cumulative minima
@@ -923,6 +994,7 @@ def cummin(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return cummin(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def cumproduct(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Cumulative products
@@ -936,6 +1008,7 @@ def cumproduct(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return cumproduct(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def cumsum(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Cumulative sums
@@ -949,6 +1022,7 @@ def cumsum(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return cumsum(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def date_shift(self, value, unit) -> 'ProcessBuilder':
         """
         Manipulates dates and times by addition or subtraction
@@ -971,6 +1045,7 @@ def date_shift(self, value, unit) -> 'ProcessBuilder':
         """
         return date_shift(date=self, value=value, unit=unit)
 
+    @openeo_process
     def dimension_labels(self, dimension) -> 'ProcessBuilder':
         """
         Get the dimension labels
@@ -982,6 +1057,7 @@ def dimension_labels(self, dimension) -> 'ProcessBuilder':
         """
         return dimension_labels(data=self, dimension=dimension)
 
+    @openeo_process
     def divide(self, y) -> 'ProcessBuilder':
         """
         Division of two numbers
@@ -993,6 +1069,7 @@ def divide(self, y) -> 'ProcessBuilder':
         """
         return divide(x=self, y=y)
 
+    @openeo_process
     def drop_dimension(self, name) -> 'ProcessBuilder':
         """
         Remove a dimension
@@ -1006,6 +1083,7 @@ def drop_dimension(self, name) -> 'ProcessBuilder':
         """
         return drop_dimension(data=self, name=name)
 
+    @openeo_process
     def e(self) -> 'ProcessBuilder':
         """
         Euler's number (e)
@@ -1014,6 +1092,7 @@ def e(self) -> 'ProcessBuilder':
         """
         return e()
 
+    @openeo_process
     def eq(self, y, delta=UNSET, case_sensitive=UNSET) -> 'ProcessBuilder':
         """
         Equal to comparison
@@ -1031,6 +1110,7 @@ def eq(self, y, delta=UNSET, case_sensitive=UNSET) -> 'ProcessBuilder':
         """
         return eq(x=self, y=y, delta=delta, case_sensitive=case_sensitive)
 
+    @openeo_process
     def exp(self) -> 'ProcessBuilder':
         """
         Exponentiation to the base e
@@ -1041,6 +1121,7 @@ def exp(self) -> 'ProcessBuilder':
         """
         return exp(p=self)
 
+    @openeo_process
     def extrema(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Minimum and maximum values
@@ -1056,6 +1137,7 @@ def extrema(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return extrema(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def filter_bands(self, bands=UNSET, wavelengths=UNSET) -> 'ProcessBuilder':
         """
         Filter the bands by names
@@ -1078,6 +1160,7 @@ def filter_bands(self, bands=UNSET, wavelengths=UNSET) -> 'ProcessBuilder':
         """
         return filter_bands(data=self, bands=bands, wavelengths=wavelengths)
 
+    @openeo_process
     def filter_bbox(self, extent) -> 'ProcessBuilder':
         """
         Spatial filter using a bounding box
@@ -1091,6 +1174,7 @@ def filter_bbox(self, extent) -> 'ProcessBuilder':
         """
         return filter_bbox(data=self, extent=extent)
 
+    @openeo_process
     def filter_labels(self, condition, dimension, context=UNSET) -> 'ProcessBuilder':
         """
         Filter dimension labels based on a condition
@@ -1109,6 +1193,7 @@ def filter_labels(self, condition, dimension, context=UNSET) -> 'ProcessBuilder'
         """
         return filter_labels(data=self, condition=condition, dimension=dimension, context=context)
 
+    @openeo_process
     def filter_spatial(self, geometries) -> 'ProcessBuilder':
         """
         Spatial filter using geometries
@@ -1122,6 +1207,7 @@ def filter_spatial(self, geometries) -> 'ProcessBuilder':
         """
         return filter_spatial(data=self, geometries=geometries)
 
+    @openeo_process
     def filter_temporal(self, extent, dimension=UNSET) -> 'ProcessBuilder':
         """
         Temporal filter based on temporal intervals
@@ -1143,6 +1229,7 @@ def filter_temporal(self, extent, dimension=UNSET) -> 'ProcessBuilder':
         """
         return filter_temporal(data=self, extent=extent, dimension=dimension)
 
+    @openeo_process
     def first(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         First element
@@ -1156,6 +1243,7 @@ def first(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return first(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def fit_class_random_forest(self, target, max_variables, num_trees=UNSET, seed=UNSET) -> 'ProcessBuilder':
         """
         Train a random forest classification model
@@ -1180,6 +1268,7 @@ def fit_class_random_forest(self, target, max_variables, num_trees=UNSET, seed=U
         """
         return fit_class_random_forest(predictors=self, target=target, max_variables=max_variables, num_trees=num_trees, seed=seed)
 
+    @openeo_process
     def fit_curve(self, parameters, function, dimension) -> 'ProcessBuilder':
         """
         Curve fitting
@@ -1199,6 +1288,7 @@ def fit_curve(self, parameters, function, dimension) -> 'ProcessBuilder':
         """
         return fit_curve(data=self, parameters=parameters, function=function, dimension=dimension)
 
+    @openeo_process
     def fit_regr_random_forest(self, target, max_variables, num_trees=UNSET, seed=UNSET) -> 'ProcessBuilder':
         """
         Train a random forest regression model
@@ -1223,6 +1313,7 @@ def fit_regr_random_forest(self, target, max_variables, num_trees=UNSET, seed=UN
         """
         return fit_regr_random_forest(predictors=self, target=target, max_variables=max_variables, num_trees=num_trees, seed=seed)
 
+    @openeo_process
     def flatten_dimensions(self, dimensions, target_dimension, label_separator=UNSET) -> 'ProcessBuilder':
         """
         Combine multiple dimensions into a single dimension
@@ -1243,6 +1334,7 @@ def flatten_dimensions(self, dimensions, target_dimension, label_separator=UNSET
         """
         return flatten_dimensions(data=self, dimensions=dimensions, target_dimension=target_dimension, label_separator=label_separator)
 
+    @openeo_process
     def floor(self) -> 'ProcessBuilder':
         """
         Round fractions down
@@ -1253,6 +1345,7 @@ def floor(self) -> 'ProcessBuilder':
         """
         return floor(x=self)
 
+    @openeo_process
     def gt(self, y) -> 'ProcessBuilder':
         """
         Greater than comparison
@@ -1265,6 +1358,7 @@ def gt(self, y) -> 'ProcessBuilder':
         """
         return gt(x=self, y=y)
 
+    @openeo_process
     def gte(self, y) -> 'ProcessBuilder':
         """
         Greater than or equal to comparison
@@ -1277,6 +1371,7 @@ def gte(self, y) -> 'ProcessBuilder':
         """
         return gte(x=self, y=y)
 
+    @openeo_process
     def if_(self, accept, reject=UNSET) -> 'ProcessBuilder':
         """
         If-Then-Else conditional
@@ -1289,6 +1384,7 @@ def if_(self, accept, reject=UNSET) -> 'ProcessBuilder':
         """
         return if_(value=self, accept=accept, reject=reject)
 
+    @openeo_process
     def inspect(self, code=UNSET, level=UNSET, message=UNSET) -> 'ProcessBuilder':
         """
         Add information to the logs
@@ -1303,6 +1399,7 @@ def inspect(self, code=UNSET, level=UNSET, message=UNSET) -> 'ProcessBuilder':
         """
         return inspect(data=self, code=code, level=level, message=message)
 
+    @openeo_process
     def int(self) -> 'ProcessBuilder':
         """
         Integer part of a number
@@ -1313,6 +1410,7 @@ def int(self) -> 'ProcessBuilder':
         """
         return int(x=self)
 
+    @openeo_process
     def is_infinite(self) -> 'ProcessBuilder':
         """
         Value is an infinite number
@@ -1323,6 +1421,7 @@ def is_infinite(self) -> 'ProcessBuilder':
         """
         return is_infinite(x=self)
 
+    @openeo_process
     def is_nan(self) -> 'ProcessBuilder':
         """
         Value is not a number
@@ -1333,6 +1432,7 @@ def is_nan(self) -> 'ProcessBuilder':
         """
         return is_nan(x=self)
 
+    @openeo_process
     def is_nodata(self) -> 'ProcessBuilder':
         """
         Value is a no-data value
@@ -1343,6 +1443,7 @@ def is_nodata(self) -> 'ProcessBuilder':
         """
         return is_nodata(x=self)
 
+    @openeo_process
     def is_valid(self) -> 'ProcessBuilder':
         """
         Value is valid data
@@ -1353,6 +1454,7 @@ def is_valid(self) -> 'ProcessBuilder':
         """
         return is_valid(x=self)
 
+    @openeo_process
     def last(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Last element
@@ -1366,6 +1468,7 @@ def last(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return last(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def linear_scale_range(self, inputMin, inputMax, outputMin=UNSET, outputMax=UNSET) -> 'ProcessBuilder':
         """
         Linear transformation between two ranges
@@ -1381,6 +1484,7 @@ def linear_scale_range(self, inputMin, inputMax, outputMin=UNSET, outputMax=UNSE
         """
         return linear_scale_range(x=self, inputMin=inputMin, inputMax=inputMax, outputMin=outputMin, outputMax=outputMax)
 
+    @openeo_process
     def ln(self) -> 'ProcessBuilder':
         """
         Natural logarithm
@@ -1391,6 +1495,7 @@ def ln(self) -> 'ProcessBuilder':
         """
         return ln(x=self)
 
+    @openeo_process
     def load_collection(self, spatial_extent, temporal_extent, bands=UNSET, properties=UNSET) -> 'ProcessBuilder':
         """
         Load a collection
@@ -1435,6 +1540,7 @@ def load_collection(self, spatial_extent, temporal_extent, bands=UNSET, properti
         """
         return load_collection(id=self, spatial_extent=spatial_extent, temporal_extent=temporal_extent, bands=bands, properties=properties)
 
+    @openeo_process
     def load_ml_model(self) -> 'ProcessBuilder':
         """
         Load a ML model
@@ -1447,6 +1553,7 @@ def load_ml_model(self) -> 'ProcessBuilder':
         """
         return load_ml_model(id=self)
 
+    @openeo_process
     def load_result(self, spatial_extent=UNSET, temporal_extent=UNSET, bands=UNSET) -> 'ProcessBuilder':
         """
         Load batch job results
@@ -1484,6 +1591,7 @@ def load_result(self, spatial_extent=UNSET, temporal_extent=UNSET, bands=UNSET)
         """
         return load_result(id=self, spatial_extent=spatial_extent, temporal_extent=temporal_extent, bands=bands)
 
+    @openeo_process
     def load_uploaded_files(self, format, options=UNSET) -> 'ProcessBuilder':
         """
         Load files from the user workspace
@@ -1502,6 +1610,7 @@ def load_uploaded_files(self, format, options=UNSET) -> 'ProcessBuilder':
         """
         return load_uploaded_files(paths=self, format=format, options=options)
 
+    @openeo_process
     def log(self, base) -> 'ProcessBuilder':
         """
         Logarithm to a base
@@ -1513,6 +1622,7 @@ def log(self, base) -> 'ProcessBuilder':
         """
         return log(x=self, base=base)
 
+    @openeo_process
     def lt(self, y) -> 'ProcessBuilder':
         """
         Less than comparison
@@ -1524,6 +1634,7 @@ def lt(self, y) -> 'ProcessBuilder':
         """
         return lt(x=self, y=y)
 
+    @openeo_process
     def lte(self, y) -> 'ProcessBuilder':
         """
         Less than or equal to comparison
@@ -1536,6 +1647,7 @@ def lte(self, y) -> 'ProcessBuilder':
         """
         return lte(x=self, y=y)
 
+    @openeo_process
     def mask(self, mask, replacement=UNSET) -> 'ProcessBuilder':
         """
         Apply a raster mask
@@ -1550,6 +1662,7 @@ def mask(self, mask, replacement=UNSET) -> 'ProcessBuilder':
         """
         return mask(data=self, mask=mask, replacement=replacement)
 
+    @openeo_process
     def mask_polygon(self, mask, replacement=UNSET, inside=UNSET) -> 'ProcessBuilder':
         """
         Apply a polygon mask
@@ -1570,6 +1683,7 @@ def mask_polygon(self, mask, replacement=UNSET, inside=UNSET) -> 'ProcessBuilder
         """
         return mask_polygon(data=self, mask=mask, replacement=replacement, inside=inside)
 
+    @openeo_process
     def max(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Maximum value
@@ -1583,6 +1697,7 @@ def max(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return max(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def mean(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Arithmetic mean (average)
@@ -1596,6 +1711,7 @@ def mean(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return mean(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def median(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Statistical median
@@ -1609,6 +1725,7 @@ def median(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return median(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def merge_cubes(self, cube2, overlap_resolver=UNSET, context=UNSET) -> 'ProcessBuilder':
         """
         Merge two data cubes
@@ -1626,6 +1743,7 @@ def merge_cubes(self, cube2, overlap_resolver=UNSET, context=UNSET) -> 'ProcessB
         """
         return merge_cubes(cube1=self, cube2=cube2, overlap_resolver=overlap_resolver, context=context)
 
+    @openeo_process
     def min(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Minimum value
@@ -1639,6 +1757,7 @@ def min(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return min(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def mod(self, y) -> 'ProcessBuilder':
         """
         Modulo
@@ -1650,6 +1769,7 @@ def mod(self, y) -> 'ProcessBuilder':
         """
         return mod(x=self, y=y)
 
+    @openeo_process
     def multiply(self, y) -> 'ProcessBuilder':
         """
         Multiplication of two numbers
@@ -1661,6 +1781,7 @@ def multiply(self, y) -> 'ProcessBuilder':
         """
         return multiply(x=self, y=y)
 
+    @openeo_process
     def nan(self) -> 'ProcessBuilder':
         """
         Not a Number (NaN)
@@ -1669,6 +1790,7 @@ def nan(self) -> 'ProcessBuilder':
         """
         return nan()
 
+    @openeo_process
     def ndvi(self, nir=UNSET, red=UNSET, target_band=UNSET) -> 'ProcessBuilder':
         """
         Normalized Difference Vegetation Index
@@ -1696,6 +1818,7 @@ def ndvi(self, nir=UNSET, red=UNSET, target_band=UNSET) -> 'ProcessBuilder':
         """
         return ndvi(data=self, nir=nir, red=red, target_band=target_band)
 
+    @openeo_process
     def neq(self, y, delta=UNSET, case_sensitive=UNSET) -> 'ProcessBuilder':
         """
         Not equal to comparison
@@ -1713,6 +1836,7 @@ def neq(self, y, delta=UNSET, case_sensitive=UNSET) -> 'ProcessBuilder':
         """
         return neq(x=self, y=y, delta=delta, case_sensitive=case_sensitive)
 
+    @openeo_process
     def normalized_difference(self, y) -> 'ProcessBuilder':
         """
         Normalized difference
@@ -1724,6 +1848,7 @@ def normalized_difference(self, y) -> 'ProcessBuilder':
         """
         return normalized_difference(x=self, y=y)
 
+    @openeo_process
     def not_(self) -> 'ProcessBuilder':
         """
         Inverting a boolean
@@ -1734,6 +1859,7 @@ def not_(self) -> 'ProcessBuilder':
         """
         return not_(x=self)
 
+    @openeo_process
     def or_(self, y) -> 'ProcessBuilder':
         """
         Logical OR
@@ -1745,6 +1871,7 @@ def or_(self, y) -> 'ProcessBuilder':
         """
         return or_(x=self, y=y)
 
+    @openeo_process
     def order(self, asc=UNSET, nodata=UNSET) -> 'ProcessBuilder':
         """
         Create a permutation
@@ -1759,6 +1886,7 @@ def order(self, asc=UNSET, nodata=UNSET) -> 'ProcessBuilder':
         """
         return order(data=self, asc=asc, nodata=nodata)
 
+    @openeo_process
     def pi(self) -> 'ProcessBuilder':
         """
         Pi (π)
@@ -1767,6 +1895,7 @@ def pi(self) -> 'ProcessBuilder':
         """
         return pi()
 
+    @openeo_process
     def power(self, p) -> 'ProcessBuilder':
         """
         Exponentiation
@@ -1778,6 +1907,7 @@ def power(self, p) -> 'ProcessBuilder':
         """
         return power(base=self, p=p)
 
+    @openeo_process
     def predict_curve(self, parameters, function, dimension, labels=UNSET) -> 'ProcessBuilder':
         """
         Predict values
@@ -1796,6 +1926,7 @@ def predict_curve(self, parameters, function, dimension, labels=UNSET) -> 'Proce
         """
         return predict_curve(data=self, parameters=parameters, function=function, dimension=dimension, labels=labels)
 
+    @openeo_process
     def predict_random_forest(self, model) -> 'ProcessBuilder':
         """
         Predict values from a Random Forest model
@@ -1809,6 +1940,7 @@ def predict_random_forest(self, model) -> 'ProcessBuilder':
         """
         return predict_random_forest(data=self, model=model)
 
+    @openeo_process
     def product(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Compute the product by multiplying numbers
@@ -1822,6 +1954,7 @@ def product(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return product(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def quantiles(self, probabilities=UNSET, q=UNSET, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Quantiles
@@ -1842,6 +1975,7 @@ def quantiles(self, probabilities=UNSET, q=UNSET, ignore_nodata=UNSET) -> 'Proce
         """
         return quantiles(data=self, probabilities=probabilities, q=q, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def rearrange(self, order) -> 'ProcessBuilder':
         """
         Rearrange an array based on a permutation
@@ -1853,6 +1987,7 @@ def rearrange(self, order) -> 'ProcessBuilder':
         """
         return rearrange(data=self, order=order)
 
+    @openeo_process
     def reduce_dimension(self, reducer, dimension, context=UNSET) -> 'ProcessBuilder':
         """
         Reduce dimensions
@@ -1871,6 +2006,7 @@ def reduce_dimension(self, reducer, dimension, context=UNSET) -> 'ProcessBuilder
         """
         return reduce_dimension(data=self, reducer=reducer, dimension=dimension, context=context)
 
+    @openeo_process
     def reduce_spatial(self, reducer, context=UNSET) -> 'ProcessBuilder':
         """
         Reduce spatial dimensions 'x' and 'y'
@@ -1887,6 +2023,7 @@ def reduce_spatial(self, reducer, context=UNSET) -> 'ProcessBuilder':
         """
         return reduce_spatial(data=self, reducer=reducer, context=context)
 
+    @openeo_process
     def rename_dimension(self, source, target) -> 'ProcessBuilder':
         """
         Rename a dimension
@@ -1903,6 +2040,7 @@ def rename_dimension(self, source, target) -> 'ProcessBuilder':
         """
         return rename_dimension(data=self, source=source, target=target)
 
+    @openeo_process
     def rename_labels(self, dimension, target, source=UNSET) -> 'ProcessBuilder':
         """
         Rename dimension labels
@@ -1925,6 +2063,7 @@ def rename_labels(self, dimension, target, source=UNSET) -> 'ProcessBuilder':
         """
         return rename_labels(data=self, dimension=dimension, target=target, source=source)
 
+    @openeo_process
     def resample_cube_spatial(self, target, method=UNSET) -> 'ProcessBuilder':
         """
         Resample the spatial dimensions to match a target data cube
@@ -1950,6 +2089,7 @@ def resample_cube_spatial(self, target, method=UNSET) -> 'ProcessBuilder':
         """
         return resample_cube_spatial(data=self, target=target, method=method)
 
+    @openeo_process
     def resample_cube_temporal(self, target, dimension=UNSET, valid_within=UNSET) -> 'ProcessBuilder':
         """
         Resample temporal dimensions to match a target data cube
@@ -1976,6 +2116,7 @@ def resample_cube_temporal(self, target, dimension=UNSET, valid_within=UNSET) ->
         """
         return resample_cube_temporal(data=self, target=target, dimension=dimension, valid_within=valid_within)
 
+    @openeo_process
     def resample_spatial(self, resolution=UNSET, projection=UNSET, method=UNSET, align=UNSET) -> 'ProcessBuilder':
         """
         Resample and warp the spatial dimensions
@@ -2010,6 +2151,7 @@ def resample_spatial(self, resolution=UNSET, projection=UNSET, method=UNSET, ali
         """
         return resample_spatial(data=self, resolution=resolution, projection=projection, method=method, align=align)
 
+    @openeo_process
     def round(self, p=UNSET) -> 'ProcessBuilder':
         """
         Round to a specified precision
@@ -2023,6 +2165,7 @@ def round(self, p=UNSET) -> 'ProcessBuilder':
         """
         return round(x=self, p=p)
 
+    @openeo_process
     def run_udf(self, udf, runtime, version=UNSET, context=UNSET) -> 'ProcessBuilder':
         """
         Run a UDF
@@ -2039,6 +2182,7 @@ def run_udf(self, udf, runtime, version=UNSET, context=UNSET) -> 'ProcessBuilder
         """
         return run_udf(data=self, udf=udf, runtime=runtime, version=version, context=context)
 
+    @openeo_process
     def run_udf_externally(self, url, context=UNSET) -> 'ProcessBuilder':
         """
         Run an externally hosted UDF container
@@ -2052,6 +2196,7 @@ def run_udf_externally(self, url, context=UNSET) -> 'ProcessBuilder':
         """
         return run_udf_externally(data=self, url=url, context=context)
 
+    @openeo_process
     def sar_backscatter(self, coefficient=UNSET, elevation_model=UNSET, mask=UNSET, contributing_area=UNSET, local_incidence_angle=UNSET, ellipsoid_incidence_angle=UNSET, noise_removal=UNSET, options=UNSET) -> 'ProcessBuilder':
         """
         Computes backscatter from SAR input
@@ -2082,6 +2227,7 @@ def sar_backscatter(self, coefficient=UNSET, elevation_model=UNSET, mask=UNSET,
         """
         return sar_backscatter(data=self, coefficient=coefficient, elevation_model=elevation_model, mask=mask, contributing_area=contributing_area, local_incidence_angle=local_incidence_angle, ellipsoid_incidence_angle=ellipsoid_incidence_angle, noise_removal=noise_removal, options=options)
 
+    @openeo_process
     def save_ml_model(self, options=UNSET) -> 'ProcessBuilder':
         """
         Save a ML model
@@ -2093,6 +2239,7 @@ def save_ml_model(self, options=UNSET) -> 'ProcessBuilder':
         """
         return save_ml_model(data=self, options=options)
 
+    @openeo_process
     def save_result(self, format, options=UNSET) -> 'ProcessBuilder':
         """
         Save processed data
@@ -2110,6 +2257,7 @@ def save_result(self, format, options=UNSET) -> 'ProcessBuilder':
         """
         return save_result(data=self, format=format, options=options)
 
+    @openeo_process
     def sd(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Standard deviation
@@ -2123,6 +2271,7 @@ def sd(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return sd(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def sgn(self) -> 'ProcessBuilder':
         """
         Signum
@@ -2133,6 +2282,7 @@ def sgn(self) -> 'ProcessBuilder':
         """
         return sgn(x=self)
 
+    @openeo_process
     def sin(self) -> 'ProcessBuilder':
         """
         Sine
@@ -2143,6 +2293,7 @@ def sin(self) -> 'ProcessBuilder':
         """
         return sin(x=self)
 
+    @openeo_process
     def sinh(self) -> 'ProcessBuilder':
         """
         Hyperbolic sine
@@ -2153,6 +2304,7 @@ def sinh(self) -> 'ProcessBuilder':
         """
         return sinh(x=self)
 
+    @openeo_process
     def sort(self, asc=UNSET, nodata=UNSET) -> 'ProcessBuilder':
         """
         Sort data
@@ -2167,6 +2319,7 @@ def sort(self, asc=UNSET, nodata=UNSET) -> 'ProcessBuilder':
         """
         return sort(data=self, asc=asc, nodata=nodata)
 
+    @openeo_process
     def sqrt(self) -> 'ProcessBuilder':
         """
         Square root
@@ -2177,6 +2330,7 @@ def sqrt(self) -> 'ProcessBuilder':
         """
         return sqrt(x=self)
 
+    @openeo_process
     def subtract(self, y) -> 'ProcessBuilder':
         """
         Subtraction of two numbers
@@ -2188,6 +2342,7 @@ def subtract(self, y) -> 'ProcessBuilder':
         """
         return subtract(x=self, y=y)
 
+    @openeo_process
     def sum(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Compute the sum by adding up numbers
@@ -2201,6 +2356,7 @@ def sum(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return sum(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def tan(self) -> 'ProcessBuilder':
         """
         Tangent
@@ -2211,6 +2367,7 @@ def tan(self) -> 'ProcessBuilder':
         """
         return tan(x=self)
 
+    @openeo_process
     def tanh(self) -> 'ProcessBuilder':
         """
         Hyperbolic tangent
@@ -2221,6 +2378,7 @@ def tanh(self) -> 'ProcessBuilder':
         """
         return tanh(x=self)
 
+    @openeo_process
     def text_begins(self, pattern, case_sensitive=UNSET) -> 'ProcessBuilder':
         """
         Text begins with another text
@@ -2233,6 +2391,7 @@ def text_begins(self, pattern, case_sensitive=UNSET) -> 'ProcessBuilder':
         """
         return text_begins(data=self, pattern=pattern, case_sensitive=case_sensitive)
 
+    @openeo_process
     def text_concat(self, separator=UNSET) -> 'ProcessBuilder':
         """
         Concatenate elements to a single text
@@ -2247,6 +2406,7 @@ def text_concat(self, separator=UNSET) -> 'ProcessBuilder':
         """
         return text_concat(data=self, separator=separator)
 
+    @openeo_process
     def text_contains(self, pattern, case_sensitive=UNSET) -> 'ProcessBuilder':
         """
         Text contains another text
@@ -2259,6 +2419,7 @@ def text_contains(self, pattern, case_sensitive=UNSET) -> 'ProcessBuilder':
         """
         return text_contains(data=self, pattern=pattern, case_sensitive=case_sensitive)
 
+    @openeo_process
     def text_ends(self, pattern, case_sensitive=UNSET) -> 'ProcessBuilder':
         """
         Text ends with another text
@@ -2271,6 +2432,7 @@ def text_ends(self, pattern, case_sensitive=UNSET) -> 'ProcessBuilder':
         """
         return text_ends(data=self, pattern=pattern, case_sensitive=case_sensitive)
 
+    @openeo_process
     def trim_cube(self) -> 'ProcessBuilder':
         """
         Remove dimension labels with no-data values
@@ -2282,6 +2444,7 @@ def trim_cube(self) -> 'ProcessBuilder':
         """
         return trim_cube(data=self)
 
+    @openeo_process
     def unflatten_dimension(self, dimension, target_dimensions, label_separator=UNSET) -> 'ProcessBuilder':
         """
         Split a single dimensions into multiple dimensions
@@ -2302,6 +2465,7 @@ def unflatten_dimension(self, dimension, target_dimensions, label_separator=UNSE
         """
         return unflatten_dimension(data=self, dimension=dimension, target_dimensions=target_dimensions, label_separator=label_separator)
 
+    @openeo_process
     def variance(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         Variance
@@ -2315,6 +2479,7 @@ def variance(self, ignore_nodata=UNSET) -> 'ProcessBuilder':
         """
         return variance(data=self, ignore_nodata=ignore_nodata)
 
+    @openeo_process
     def vector_buffer(self, distance) -> 'ProcessBuilder':
         """
         Buffer geometries by distance
@@ -2331,6 +2496,7 @@ def vector_buffer(self, distance) -> 'ProcessBuilder':
         """
         return vector_buffer(geometries=self, distance=distance)
 
+    @openeo_process
     def vector_to_random_points(self, geometry_count=UNSET, total_count=UNSET, group=UNSET, seed=UNSET) -> 'ProcessBuilder':
         """
         Sample random points from geometries
@@ -2353,6 +2519,7 @@ def vector_to_random_points(self, geometry_count=UNSET, total_count=UNSET, group
         """
         return vector_to_random_points(data=self, geometry_count=geometry_count, total_count=total_count, group=group, seed=seed)
 
+    @openeo_process
     def vector_to_regular_points(self, distance, group=UNSET) -> 'ProcessBuilder':
         """
         Sample regular points from geometries
@@ -2377,6 +2544,7 @@ def vector_to_regular_points(self, distance, group=UNSET) -> 'ProcessBuilder':
         """
         return vector_to_regular_points(data=self, distance=distance, group=group)
 
+    @openeo_process
     def xor(self, y) -> 'ProcessBuilder':
         """
         Logical XOR (exclusive or)
@@ -2395,6 +2563,7 @@ def xor(self, y) -> 'ProcessBuilder':
 _process = ProcessBuilder.process
 
 
+@openeo_process
 def absolute(x) -> ProcessBuilder:
     """
     Absolute value
@@ -2406,6 +2575,7 @@ def absolute(x) -> ProcessBuilder:
     return _process('absolute', x=x)
 
 
+@openeo_process
 def add(x, y) -> ProcessBuilder:
     """
     Addition of two numbers
@@ -2418,6 +2588,7 @@ def add(x, y) -> ProcessBuilder:
     return _process('add', x=x, y=y)
 
 
+@openeo_process
 def add_dimension(data, name, label, type=UNSET) -> ProcessBuilder:
     """
     Add a new dimension
@@ -2433,6 +2604,7 @@ def add_dimension(data, name, label, type=UNSET) -> ProcessBuilder:
     return _process('add_dimension', data=data, name=name, label=label, type=type)
 
 
+@openeo_process
 def aggregate_spatial(data, geometries, reducer, target_dimension=UNSET, context=UNSET) -> ProcessBuilder:
     """
     Zonal statistics for geometries
@@ -2473,6 +2645,7 @@ def aggregate_spatial(data, geometries, reducer, target_dimension=UNSET, context
     return _process('aggregate_spatial', data=data, geometries=geometries, reducer=reducer, target_dimension=target_dimension, context=context)
 
 
+@openeo_process
 def aggregate_spatial_window(data, reducer, size, boundary=UNSET, align=UNSET, context=UNSET) -> ProcessBuilder:
     """
     Zonal statistics for rectangular windows
@@ -2502,6 +2675,7 @@ def aggregate_spatial_window(data, reducer, size, boundary=UNSET, align=UNSET, c
     return _process('aggregate_spatial_window', data=data, reducer=reducer, size=size, boundary=boundary, align=align, context=context)
 
 
+@openeo_process
 def aggregate_temporal(data, intervals, reducer, labels=UNSET, dimension=UNSET, context=UNSET) -> ProcessBuilder:
     """
     Temporal aggregations
@@ -2535,6 +2709,7 @@ def aggregate_temporal(data, intervals, reducer, labels=UNSET, dimension=UNSET,
     return _process('aggregate_temporal', data=data, intervals=intervals, reducer=reducer, labels=labels, dimension=dimension, context=context)
 
 
+@openeo_process
 def aggregate_temporal_period(data, period, reducer, dimension=UNSET, context=UNSET) -> ProcessBuilder:
     """
     Temporal aggregations based on calendar hierarchies
@@ -2579,6 +2754,7 @@ def aggregate_temporal_period(data, period, reducer, dimension=UNSET, context=UN
     return _process('aggregate_temporal_period', data=data, period=period, reducer=reducer, dimension=dimension, context=context)
 
 
+@openeo_process
 def all(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Are all of the values true?
@@ -2591,6 +2767,7 @@ def all(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('all', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def and_(x, y) -> ProcessBuilder:
     """
     Logical AND
@@ -2603,6 +2780,7 @@ def and_(x, y) -> ProcessBuilder:
     return _process('and', x=x, y=y)
 
 
+@openeo_process
 def anomaly(data, normals, period) -> ProcessBuilder:
     """
     Compute anomalies
@@ -2642,6 +2820,7 @@ def anomaly(data, normals, period) -> ProcessBuilder:
     return _process('anomaly', data=data, normals=normals, period=period)
 
 
+@openeo_process
 def any(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Is at least one value true?
@@ -2654,6 +2833,7 @@ def any(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('any', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def apply(data, process, context=UNSET) -> ProcessBuilder:
     """
     Apply a process to each pixel
@@ -2670,6 +2850,7 @@ def apply(data, process, context=UNSET) -> ProcessBuilder:
     return _process('apply', data=data, process=process, context=context)
 
 
+@openeo_process
 def apply_dimension(data, process, dimension, target_dimension=UNSET, context=UNSET) -> ProcessBuilder:
     """
     Apply a process to pixels along a dimension
@@ -2705,6 +2886,7 @@ def apply_dimension(data, process, dimension, target_dimension=UNSET, context=UN
     return _process('apply_dimension', data=data, process=process, dimension=dimension, target_dimension=target_dimension, context=context)
 
 
+@openeo_process
 def apply_kernel(data, kernel, factor=UNSET, border=UNSET, replace_invalid=UNSET) -> ProcessBuilder:
     """
     Apply a spatial convolution with a kernel
@@ -2731,6 +2913,7 @@ def apply_kernel(data, kernel, factor=UNSET, border=UNSET, replace_invalid=UNSET
     return _process('apply_kernel', data=data, kernel=kernel, factor=factor, border=border, replace_invalid=replace_invalid)
 
 
+@openeo_process
 def apply_neighborhood(data, process, size, overlap=UNSET, context=UNSET) -> ProcessBuilder:
     """
     Apply a process to pixels in a n-dimensional neighborhood
@@ -2755,6 +2938,7 @@ def apply_neighborhood(data, process, size, overlap=UNSET, context=UNSET) -> Pro
     return _process('apply_neighborhood', data=data, process=process, size=size, overlap=overlap, context=context)
 
 
+@openeo_process
 def arccos(x) -> ProcessBuilder:
     """
     Inverse cosine
@@ -2766,6 +2950,7 @@ def arccos(x) -> ProcessBuilder:
     return _process('arccos', x=x)
 
 
+@openeo_process
 def arcosh(x) -> ProcessBuilder:
     """
     Inverse hyperbolic cosine
@@ -2777,6 +2962,7 @@ def arcosh(x) -> ProcessBuilder:
     return _process('arcosh', x=x)
 
 
+@openeo_process
 def arcsin(x) -> ProcessBuilder:
     """
     Inverse sine
@@ -2788,6 +2974,7 @@ def arcsin(x) -> ProcessBuilder:
     return _process('arcsin', x=x)
 
 
+@openeo_process
 def arctan(x) -> ProcessBuilder:
     """
     Inverse tangent
@@ -2799,6 +2986,7 @@ def arctan(x) -> ProcessBuilder:
     return _process('arctan', x=x)
 
 
+@openeo_process
 def arctan2(y, x) -> ProcessBuilder:
     """
     Inverse tangent of two numbers
@@ -2811,6 +2999,7 @@ def arctan2(y, x) -> ProcessBuilder:
     return _process('arctan2', y=y, x=x)
 
 
+@openeo_process
 def ard_normalized_radar_backscatter(data, elevation_model=UNSET, contributing_area=UNSET, ellipsoid_incidence_angle=UNSET, noise_removal=UNSET, options=UNSET) -> ProcessBuilder:
     """
     CARD4L compliant SAR NRB generation
@@ -2837,6 +3026,7 @@ def ard_normalized_radar_backscatter(data, elevation_model=UNSET, contributing_a
     return _process('ard_normalized_radar_backscatter', data=data, elevation_model=elevation_model, contributing_area=contributing_area, ellipsoid_incidence_angle=ellipsoid_incidence_angle, noise_removal=noise_removal, options=options)
 
 
+@openeo_process
 def ard_surface_reflectance(data, atmospheric_correction_method, cloud_detection_method, elevation_model=UNSET, atmospheric_correction_options=UNSET, cloud_detection_options=UNSET) -> ProcessBuilder:
     """
     CARD4L compliant Surface Reflectance generation
@@ -2884,6 +3074,7 @@ def ard_surface_reflectance(data, atmospheric_correction_method, cloud_detection
     return _process('ard_surface_reflectance', data=data, atmospheric_correction_method=atmospheric_correction_method, cloud_detection_method=cloud_detection_method, elevation_model=elevation_model, atmospheric_correction_options=atmospheric_correction_options, cloud_detection_options=cloud_detection_options)
 
 
+@openeo_process
 def array_append(data, value, label=UNSET) -> ProcessBuilder:
     """
     Append a value to an array
@@ -2899,6 +3090,7 @@ def array_append(data, value, label=UNSET) -> ProcessBuilder:
     return _process('array_append', data=data, value=value, label=label)
 
 
+@openeo_process
 def array_apply(data, process, context=UNSET) -> ProcessBuilder:
     """
     Apply a process to each array element
@@ -2915,6 +3107,7 @@ def array_apply(data, process, context=UNSET) -> ProcessBuilder:
     return _process('array_apply', data=data, process=process, context=context)
 
 
+@openeo_process
 def array_concat(array1, array2) -> ProcessBuilder:
     """
     Merge two arrays
@@ -2927,6 +3120,7 @@ def array_concat(array1, array2) -> ProcessBuilder:
     return _process('array_concat', array1=array1, array2=array2)
 
 
+@openeo_process
 def array_contains(data, value) -> ProcessBuilder:
     """
     Check whether the array contains a given value
@@ -2939,6 +3133,7 @@ def array_contains(data, value) -> ProcessBuilder:
     return _process('array_contains', data=data, value=value)
 
 
+@openeo_process
 def array_create(data=UNSET, repeat=UNSET) -> ProcessBuilder:
     """
     Create an array
@@ -2952,6 +3147,7 @@ def array_create(data=UNSET, repeat=UNSET) -> ProcessBuilder:
     return _process('array_create', data=data, repeat=repeat)
 
 
+@openeo_process
 def array_create_labeled(data, labels) -> ProcessBuilder:
     """
     Create a labeled array
@@ -2964,6 +3160,7 @@ def array_create_labeled(data, labels) -> ProcessBuilder:
     return _process('array_create_labeled', data=data, labels=labels)
 
 
+@openeo_process
 def array_element(data, index=UNSET, label=UNSET, return_nodata=UNSET) -> ProcessBuilder:
     """
     Get an element from an array
@@ -2980,6 +3177,7 @@ def array_element(data, index=UNSET, label=UNSET, return_nodata=UNSET) -> Proces
     return _process('array_element', data=data, index=index, label=label, return_nodata=return_nodata)
 
 
+@openeo_process
 def array_filter(data, condition, context=UNSET) -> ProcessBuilder:
     """
     Filter an array based on a condition
@@ -2995,6 +3193,7 @@ def array_filter(data, condition, context=UNSET) -> ProcessBuilder:
     return _process('array_filter', data=data, condition=condition, context=context)
 
 
+@openeo_process
 def array_find(data, value, reverse=UNSET) -> ProcessBuilder:
     """
     Get the index for a value in an array
@@ -3010,6 +3209,7 @@ def array_find(data, value, reverse=UNSET) -> ProcessBuilder:
     return _process('array_find', data=data, value=value, reverse=reverse)
 
 
+@openeo_process
 def array_find_label(data, label) -> ProcessBuilder:
     """
     Get the index for a label in a labeled array
@@ -3023,6 +3223,7 @@ def array_find_label(data, label) -> ProcessBuilder:
     return _process('array_find_label', data=data, label=label)
 
 
+@openeo_process
 def array_interpolate_linear(data) -> ProcessBuilder:
     """
     One-dimensional linear interpolation for arrays
@@ -3037,6 +3238,7 @@ def array_interpolate_linear(data) -> ProcessBuilder:
     return _process('array_interpolate_linear', data=data)
 
 
+@openeo_process
 def array_labels(data) -> ProcessBuilder:
     """
     Get the labels for an array
@@ -3048,6 +3250,7 @@ def array_labels(data) -> ProcessBuilder:
     return _process('array_labels', data=data)
 
 
+@openeo_process
 def array_modify(data, values, index, length=UNSET) -> ProcessBuilder:
     """
     Change the content of an array (remove, insert, update)
@@ -3068,6 +3271,7 @@ def array_modify(data, values, index, length=UNSET) -> ProcessBuilder:
     return _process('array_modify', data=data, values=values, index=index, length=length)
 
 
+@openeo_process
 def arsinh(x) -> ProcessBuilder:
     """
     Inverse hyperbolic sine
@@ -3079,6 +3283,7 @@ def arsinh(x) -> ProcessBuilder:
     return _process('arsinh', x=x)
 
 
+@openeo_process
 def artanh(x) -> ProcessBuilder:
     """
     Inverse hyperbolic tangent
@@ -3090,6 +3295,7 @@ def artanh(x) -> ProcessBuilder:
     return _process('artanh', x=x)
 
 
+@openeo_process
 def atmospheric_correction(data, method, elevation_model=UNSET, options=UNSET) -> ProcessBuilder:
     """
     Apply atmospheric correction
@@ -3108,6 +3314,7 @@ def atmospheric_correction(data, method, elevation_model=UNSET, options=UNSET) -
     return _process('atmospheric_correction', data=data, method=method, elevation_model=elevation_model, options=options)
 
 
+@openeo_process
 def between(x, min, max, exclude_max=UNSET) -> ProcessBuilder:
     """
     Between comparison
@@ -3122,6 +3329,7 @@ def between(x, min, max, exclude_max=UNSET) -> ProcessBuilder:
     return _process('between', x=x, min=min, max=max, exclude_max=exclude_max)
 
 
+@openeo_process
 def ceil(x) -> ProcessBuilder:
     """
     Round fractions up
@@ -3133,6 +3341,7 @@ def ceil(x) -> ProcessBuilder:
     return _process('ceil', x=x)
 
 
+@openeo_process
 def climatological_normal(data, period, climatology_period=UNSET) -> ProcessBuilder:
     """
     Compute climatology normals
@@ -3162,6 +3371,7 @@ def climatological_normal(data, period, climatology_period=UNSET) -> ProcessBuil
     return _process('climatological_normal', data=data, period=period, climatology_period=climatology_period)
 
 
+@openeo_process
 def clip(x, min, max) -> ProcessBuilder:
     """
     Clip a value between a minimum and a maximum
@@ -3177,6 +3387,7 @@ def clip(x, min, max) -> ProcessBuilder:
     return _process('clip', x=x, min=min, max=max)
 
 
+@openeo_process
 def cloud_detection(data, method, options=UNSET) -> ProcessBuilder:
     """
     Create cloud masks
@@ -3196,6 +3407,7 @@ def cloud_detection(data, method, options=UNSET) -> ProcessBuilder:
     return _process('cloud_detection', data=data, method=method, options=options)
 
 
+@openeo_process
 def constant(x) -> ProcessBuilder:
     """
     Define a constant value
@@ -3207,6 +3419,7 @@ def constant(x) -> ProcessBuilder:
     return _process('constant', x=x)
 
 
+@openeo_process
 def cos(x) -> ProcessBuilder:
     """
     Cosine
@@ -3218,6 +3431,7 @@ def cos(x) -> ProcessBuilder:
     return _process('cos', x=x)
 
 
+@openeo_process
 def cosh(x) -> ProcessBuilder:
     """
     Hyperbolic cosine
@@ -3229,6 +3443,7 @@ def cosh(x) -> ProcessBuilder:
     return _process('cosh', x=x)
 
 
+@openeo_process
 def count(data, condition=UNSET, context=UNSET) -> ProcessBuilder:
     """
     Count the number of elements
@@ -3245,6 +3460,7 @@ def count(data, condition=UNSET, context=UNSET) -> ProcessBuilder:
     return _process('count', data=data, condition=condition, context=context)
 
 
+@openeo_process
 def create_raster_cube() -> ProcessBuilder:
     """
     Create an empty raster data cube
@@ -3254,6 +3470,7 @@ def create_raster_cube() -> ProcessBuilder:
     return _process('create_raster_cube', )
 
 
+@openeo_process
 def cummax(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Cumulative maxima
@@ -3267,6 +3484,7 @@ def cummax(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('cummax', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def cummin(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Cumulative minima
@@ -3280,6 +3498,7 @@ def cummin(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('cummin', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def cumproduct(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Cumulative products
@@ -3293,6 +3512,7 @@ def cumproduct(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('cumproduct', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def cumsum(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Cumulative sums
@@ -3306,6 +3526,7 @@ def cumsum(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('cumsum', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def date_shift(date, value, unit) -> ProcessBuilder:
     """
     Manipulates dates and times by addition or subtraction
@@ -3329,6 +3550,7 @@ def date_shift(date, value, unit) -> ProcessBuilder:
     return _process('date_shift', date=date, value=value, unit=unit)
 
 
+@openeo_process
 def dimension_labels(data, dimension) -> ProcessBuilder:
     """
     Get the dimension labels
@@ -3341,6 +3563,7 @@ def dimension_labels(data, dimension) -> ProcessBuilder:
     return _process('dimension_labels', data=data, dimension=dimension)
 
 
+@openeo_process
 def divide(x, y) -> ProcessBuilder:
     """
     Division of two numbers
@@ -3353,6 +3576,7 @@ def divide(x, y) -> ProcessBuilder:
     return _process('divide', x=x, y=y)
 
 
+@openeo_process
 def drop_dimension(data, name) -> ProcessBuilder:
     """
     Remove a dimension
@@ -3367,6 +3591,7 @@ def drop_dimension(data, name) -> ProcessBuilder:
     return _process('drop_dimension', data=data, name=name)
 
 
+@openeo_process
 def e() -> ProcessBuilder:
     """
     Euler's number (e)
@@ -3376,6 +3601,7 @@ def e() -> ProcessBuilder:
     return _process('e', )
 
 
+@openeo_process
 def eq(x, y, delta=UNSET, case_sensitive=UNSET) -> ProcessBuilder:
     """
     Equal to comparison
@@ -3394,6 +3620,7 @@ def eq(x, y, delta=UNSET, case_sensitive=UNSET) -> ProcessBuilder:
     return _process('eq', x=x, y=y, delta=delta, case_sensitive=case_sensitive)
 
 
+@openeo_process
 def exp(p) -> ProcessBuilder:
     """
     Exponentiation to the base e
@@ -3405,6 +3632,7 @@ def exp(p) -> ProcessBuilder:
     return _process('exp', p=p)
 
 
+@openeo_process
 def extrema(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Minimum and maximum values
@@ -3421,6 +3649,7 @@ def extrema(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('extrema', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def filter_bands(data, bands=UNSET, wavelengths=UNSET) -> ProcessBuilder:
     """
     Filter the bands by names
@@ -3443,6 +3672,7 @@ def filter_bands(data, bands=UNSET, wavelengths=UNSET) -> ProcessBuilder:
     return _process('filter_bands', data=data, bands=bands, wavelengths=wavelengths)
 
 
+@openeo_process
 def filter_bbox(data, extent) -> ProcessBuilder:
     """
     Spatial filter using a bounding box
@@ -3457,6 +3687,7 @@ def filter_bbox(data, extent) -> ProcessBuilder:
     return _process('filter_bbox', data=data, extent=extent)
 
 
+@openeo_process
 def filter_labels(data, condition, dimension, context=UNSET) -> ProcessBuilder:
     """
     Filter dimension labels based on a condition
@@ -3476,6 +3707,7 @@ def filter_labels(data, condition, dimension, context=UNSET) -> ProcessBuilder:
     return _process('filter_labels', data=data, condition=condition, dimension=dimension, context=context)
 
 
+@openeo_process
 def filter_spatial(data, geometries) -> ProcessBuilder:
     """
     Spatial filter using geometries
@@ -3490,6 +3722,7 @@ def filter_spatial(data, geometries) -> ProcessBuilder:
     return _process('filter_spatial', data=data, geometries=geometries)
 
 
+@openeo_process
 def filter_temporal(data, extent, dimension=UNSET) -> ProcessBuilder:
     """
     Temporal filter based on temporal intervals
@@ -3512,6 +3745,7 @@ def filter_temporal(data, extent, dimension=UNSET) -> ProcessBuilder:
     return _process('filter_temporal', data=data, extent=extent, dimension=dimension)
 
 
+@openeo_process
 def first(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     First element
@@ -3526,6 +3760,7 @@ def first(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('first', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def fit_class_random_forest(predictors, target, max_variables, num_trees=UNSET, seed=UNSET) -> ProcessBuilder:
     """
     Train a random forest classification model
@@ -3550,6 +3785,7 @@ def fit_class_random_forest(predictors, target, max_variables, num_trees=UNSET,
     return _process('fit_class_random_forest', predictors=predictors, target=target, max_variables=max_variables, num_trees=num_trees, seed=seed)
 
 
+@openeo_process
 def fit_curve(data, parameters, function, dimension) -> ProcessBuilder:
     """
     Curve fitting
@@ -3570,6 +3806,7 @@ def fit_curve(data, parameters, function, dimension) -> ProcessBuilder:
     return _process('fit_curve', data=data, parameters=parameters, function=function, dimension=dimension)
 
 
+@openeo_process
 def fit_regr_random_forest(predictors, target, max_variables, num_trees=UNSET, seed=UNSET) -> ProcessBuilder:
     """
     Train a random forest regression model
@@ -3594,6 +3831,7 @@ def fit_regr_random_forest(predictors, target, max_variables, num_trees=UNSET, s
     return _process('fit_regr_random_forest', predictors=predictors, target=target, max_variables=max_variables, num_trees=num_trees, seed=seed)
 
 
+@openeo_process
 def flatten_dimensions(data, dimensions, target_dimension, label_separator=UNSET) -> ProcessBuilder:
     """
     Combine multiple dimensions into a single dimension
@@ -3615,6 +3853,7 @@ def flatten_dimensions(data, dimensions, target_dimension, label_separator=UNSET
     return _process('flatten_dimensions', data=data, dimensions=dimensions, target_dimension=target_dimension, label_separator=label_separator)
 
 
+@openeo_process
 def floor(x) -> ProcessBuilder:
     """
     Round fractions down
@@ -3626,6 +3865,7 @@ def floor(x) -> ProcessBuilder:
     return _process('floor', x=x)
 
 
+@openeo_process
 def gt(x, y) -> ProcessBuilder:
     """
     Greater than comparison
@@ -3638,6 +3878,7 @@ def gt(x, y) -> ProcessBuilder:
     return _process('gt', x=x, y=y)
 
 
+@openeo_process
 def gte(x, y) -> ProcessBuilder:
     """
     Greater than or equal to comparison
@@ -3650,6 +3891,7 @@ def gte(x, y) -> ProcessBuilder:
     return _process('gte', x=x, y=y)
 
 
+@openeo_process
 def if_(value, accept, reject=UNSET) -> ProcessBuilder:
     """
     If-Then-Else conditional
@@ -3663,6 +3905,7 @@ def if_(value, accept, reject=UNSET) -> ProcessBuilder:
     return _process('if', value=value, accept=accept, reject=reject)
 
 
+@openeo_process
 def inspect(data, code=UNSET, level=UNSET, message=UNSET) -> ProcessBuilder:
     """
     Add information to the logs
@@ -3678,6 +3921,7 @@ def inspect(data, code=UNSET, level=UNSET, message=UNSET) -> ProcessBuilder:
     return _process('inspect', data=data, code=code, level=level, message=message)
 
 
+@openeo_process
 def int(x) -> ProcessBuilder:
     """
     Integer part of a number
@@ -3689,6 +3933,7 @@ def int(x) -> ProcessBuilder:
     return _process('int', x=x)
 
 
+@openeo_process
 def is_infinite(x) -> ProcessBuilder:
     """
     Value is an infinite number
@@ -3700,6 +3945,7 @@ def is_infinite(x) -> ProcessBuilder:
     return _process('is_infinite', x=x)
 
 
+@openeo_process
 def is_nan(x) -> ProcessBuilder:
     """
     Value is not a number
@@ -3711,6 +3957,7 @@ def is_nan(x) -> ProcessBuilder:
     return _process('is_nan', x=x)
 
 
+@openeo_process
 def is_nodata(x) -> ProcessBuilder:
     """
     Value is a no-data value
@@ -3722,6 +3969,7 @@ def is_nodata(x) -> ProcessBuilder:
     return _process('is_nodata', x=x)
 
 
+@openeo_process
 def is_valid(x) -> ProcessBuilder:
     """
     Value is valid data
@@ -3733,6 +3981,7 @@ def is_valid(x) -> ProcessBuilder:
     return _process('is_valid', x=x)
 
 
+@openeo_process
 def last(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Last element
@@ -3746,6 +3995,7 @@ def last(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('last', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def linear_scale_range(x, inputMin, inputMax, outputMin=UNSET, outputMax=UNSET) -> ProcessBuilder:
     """
     Linear transformation between two ranges
@@ -3762,6 +4012,7 @@ def linear_scale_range(x, inputMin, inputMax, outputMin=UNSET, outputMax=UNSET)
     return _process('linear_scale_range', x=x, inputMin=inputMin, inputMax=inputMax, outputMin=outputMin, outputMax=outputMax)
 
 
+@openeo_process
 def ln(x) -> ProcessBuilder:
     """
     Natural logarithm
@@ -3773,6 +4024,7 @@ def ln(x) -> ProcessBuilder:
     return _process('ln', x=x)
 
 
+@openeo_process
 def load_collection(id, spatial_extent, temporal_extent, bands=UNSET, properties=UNSET) -> ProcessBuilder:
     """
     Load a collection
@@ -3817,6 +4069,7 @@ def load_collection(id, spatial_extent, temporal_extent, bands=UNSET, properties
     return _process('load_collection', id=id, spatial_extent=spatial_extent, temporal_extent=temporal_extent, bands=bands, properties=properties)
 
 
+@openeo_process
 def load_ml_model(id) -> ProcessBuilder:
     """
     Load a ML model
@@ -3830,6 +4083,7 @@ def load_ml_model(id) -> ProcessBuilder:
     return _process('load_ml_model', id=id)
 
 
+@openeo_process
 def load_result(id, spatial_extent=UNSET, temporal_extent=UNSET, bands=UNSET) -> ProcessBuilder:
     """
     Load batch job results
@@ -3867,6 +4121,7 @@ def load_result(id, spatial_extent=UNSET, temporal_extent=UNSET, bands=UNSET) ->
     return _process('load_result', id=id, spatial_extent=spatial_extent, temporal_extent=temporal_extent, bands=bands)
 
 
+@openeo_process
 def load_uploaded_files(paths, format, options=UNSET) -> ProcessBuilder:
     """
     Load files from the user workspace
@@ -3886,6 +4141,7 @@ def load_uploaded_files(paths, format, options=UNSET) -> ProcessBuilder:
     return _process('load_uploaded_files', paths=paths, format=format, options=options)
 
 
+@openeo_process
 def log(x, base) -> ProcessBuilder:
     """
     Logarithm to a base
@@ -3898,6 +4154,7 @@ def log(x, base) -> ProcessBuilder:
     return _process('log', x=x, base=base)
 
 
+@openeo_process
 def lt(x, y) -> ProcessBuilder:
     """
     Less than comparison
@@ -3910,6 +4167,7 @@ def lt(x, y) -> ProcessBuilder:
     return _process('lt', x=x, y=y)
 
 
+@openeo_process
 def lte(x, y) -> ProcessBuilder:
     """
     Less than or equal to comparison
@@ -3922,6 +4180,7 @@ def lte(x, y) -> ProcessBuilder:
     return _process('lte', x=x, y=y)
 
 
+@openeo_process
 def mask(data, mask, replacement=UNSET) -> ProcessBuilder:
     """
     Apply a raster mask
@@ -3937,6 +4196,7 @@ def mask(data, mask, replacement=UNSET) -> ProcessBuilder:
     return _process('mask', data=data, mask=mask, replacement=replacement)
 
 
+@openeo_process
 def mask_polygon(data, mask, replacement=UNSET, inside=UNSET) -> ProcessBuilder:
     """
     Apply a polygon mask
@@ -3957,6 +4217,7 @@ def mask_polygon(data, mask, replacement=UNSET, inside=UNSET) -> ProcessBuilder:
     return _process('mask_polygon', data=data, mask=mask, replacement=replacement, inside=inside)
 
 
+@openeo_process
 def max(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Maximum value
@@ -3970,6 +4231,7 @@ def max(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('max', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def mean(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Arithmetic mean (average)
@@ -3983,6 +4245,7 @@ def mean(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('mean', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def median(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Statistical median
@@ -3996,6 +4259,7 @@ def median(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('median', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def merge_cubes(cube1, cube2, overlap_resolver=UNSET, context=UNSET) -> ProcessBuilder:
     """
     Merge two data cubes
@@ -4014,6 +4278,7 @@ def merge_cubes(cube1, cube2, overlap_resolver=UNSET, context=UNSET) -> ProcessB
     return _process('merge_cubes', cube1=cube1, cube2=cube2, overlap_resolver=overlap_resolver, context=context)
 
 
+@openeo_process
 def min(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Minimum value
@@ -4027,6 +4292,7 @@ def min(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('min', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def mod(x, y) -> ProcessBuilder:
     """
     Modulo
@@ -4039,6 +4305,7 @@ def mod(x, y) -> ProcessBuilder:
     return _process('mod', x=x, y=y)
 
 
+@openeo_process
 def multiply(x, y) -> ProcessBuilder:
     """
     Multiplication of two numbers
@@ -4051,6 +4318,7 @@ def multiply(x, y) -> ProcessBuilder:
     return _process('multiply', x=x, y=y)
 
 
+@openeo_process
 def nan() -> ProcessBuilder:
     """
     Not a Number (NaN)
@@ -4060,6 +4328,7 @@ def nan() -> ProcessBuilder:
     return _process('nan', )
 
 
+@openeo_process
 def ndvi(data, nir=UNSET, red=UNSET, target_band=UNSET) -> ProcessBuilder:
     """
     Normalized Difference Vegetation Index
@@ -4088,6 +4357,7 @@ def ndvi(data, nir=UNSET, red=UNSET, target_band=UNSET) -> ProcessBuilder:
     return _process('ndvi', data=data, nir=nir, red=red, target_band=target_band)
 
 
+@openeo_process
 def neq(x, y, delta=UNSET, case_sensitive=UNSET) -> ProcessBuilder:
     """
     Not equal to comparison
@@ -4106,6 +4376,7 @@ def neq(x, y, delta=UNSET, case_sensitive=UNSET) -> ProcessBuilder:
     return _process('neq', x=x, y=y, delta=delta, case_sensitive=case_sensitive)
 
 
+@openeo_process
 def normalized_difference(x, y) -> ProcessBuilder:
     """
     Normalized difference
@@ -4118,6 +4389,7 @@ def normalized_difference(x, y) -> ProcessBuilder:
     return _process('normalized_difference', x=x, y=y)
 
 
+@openeo_process
 def not_(x) -> ProcessBuilder:
     """
     Inverting a boolean
@@ -4129,6 +4401,7 @@ def not_(x) -> ProcessBuilder:
     return _process('not', x=x)
 
 
+@openeo_process
 def or_(x, y) -> ProcessBuilder:
     """
     Logical OR
@@ -4141,6 +4414,7 @@ def or_(x, y) -> ProcessBuilder:
     return _process('or', x=x, y=y)
 
 
+@openeo_process
 def order(data, asc=UNSET, nodata=UNSET) -> ProcessBuilder:
     """
     Create a permutation
@@ -4156,6 +4430,7 @@ def order(data, asc=UNSET, nodata=UNSET) -> ProcessBuilder:
     return _process('order', data=data, asc=asc, nodata=nodata)
 
 
+@openeo_process
 def pi() -> ProcessBuilder:
     """
     Pi (π)
@@ -4165,6 +4440,7 @@ def pi() -> ProcessBuilder:
     return _process('pi', )
 
 
+@openeo_process
 def power(base, p) -> ProcessBuilder:
     """
     Exponentiation
@@ -4177,6 +4453,7 @@ def power(base, p) -> ProcessBuilder:
     return _process('power', base=base, p=p)
 
 
+@openeo_process
 def predict_curve(data, parameters, function, dimension, labels=UNSET) -> ProcessBuilder:
     """
     Predict values
@@ -4196,6 +4473,7 @@ def predict_curve(data, parameters, function, dimension, labels=UNSET) -> Proces
     return _process('predict_curve', data=data, parameters=parameters, function=function, dimension=dimension, labels=labels)
 
 
+@openeo_process
 def predict_random_forest(data, model) -> ProcessBuilder:
     """
     Predict values from a Random Forest model
@@ -4209,6 +4487,7 @@ def predict_random_forest(data, model) -> ProcessBuilder:
     return _process('predict_random_forest', data=data, model=model)
 
 
+@openeo_process
 def product(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Compute the product by multiplying numbers
@@ -4222,6 +4501,7 @@ def product(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('product', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def quantiles(data, probabilities=UNSET, q=UNSET, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Quantiles
@@ -4243,6 +4523,7 @@ def quantiles(data, probabilities=UNSET, q=UNSET, ignore_nodata=UNSET) -> Proces
     return _process('quantiles', data=data, probabilities=probabilities, q=q, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def rearrange(data, order) -> ProcessBuilder:
     """
     Rearrange an array based on a permutation
@@ -4255,6 +4536,7 @@ def rearrange(data, order) -> ProcessBuilder:
     return _process('rearrange', data=data, order=order)
 
 
+@openeo_process
 def reduce_dimension(data, reducer, dimension, context=UNSET) -> ProcessBuilder:
     """
     Reduce dimensions
@@ -4274,6 +4556,7 @@ def reduce_dimension(data, reducer, dimension, context=UNSET) -> ProcessBuilder:
     return _process('reduce_dimension', data=data, reducer=reducer, dimension=dimension, context=context)
 
 
+@openeo_process
 def reduce_spatial(data, reducer, context=UNSET) -> ProcessBuilder:
     """
     Reduce spatial dimensions 'x' and 'y'
@@ -4291,6 +4574,7 @@ def reduce_spatial(data, reducer, context=UNSET) -> ProcessBuilder:
     return _process('reduce_spatial', data=data, reducer=reducer, context=context)
 
 
+@openeo_process
 def rename_dimension(data, source, target) -> ProcessBuilder:
     """
     Rename a dimension
@@ -4308,6 +4592,7 @@ def rename_dimension(data, source, target) -> ProcessBuilder:
     return _process('rename_dimension', data=data, source=source, target=target)
 
 
+@openeo_process
 def rename_labels(data, dimension, target, source=UNSET) -> ProcessBuilder:
     """
     Rename dimension labels
@@ -4331,6 +4616,7 @@ def rename_labels(data, dimension, target, source=UNSET) -> ProcessBuilder:
     return _process('rename_labels', data=data, dimension=dimension, target=target, source=source)
 
 
+@openeo_process
 def resample_cube_spatial(data, target, method=UNSET) -> ProcessBuilder:
     """
     Resample the spatial dimensions to match a target data cube
@@ -4356,6 +4642,7 @@ def resample_cube_spatial(data, target, method=UNSET) -> ProcessBuilder:
     return _process('resample_cube_spatial', data=data, target=target, method=method)
 
 
+@openeo_process
 def resample_cube_temporal(data, target, dimension=UNSET, valid_within=UNSET) -> ProcessBuilder:
     """
     Resample temporal dimensions to match a target data cube
@@ -4381,6 +4668,7 @@ def resample_cube_temporal(data, target, dimension=UNSET, valid_within=UNSET) ->
     return _process('resample_cube_temporal', data=data, target=target, dimension=dimension, valid_within=valid_within)
 
 
+@openeo_process
 def resample_spatial(data, resolution=UNSET, projection=UNSET, method=UNSET, align=UNSET) -> ProcessBuilder:
     """
     Resample and warp the spatial dimensions
@@ -4414,6 +4702,7 @@ def resample_spatial(data, resolution=UNSET, projection=UNSET, method=UNSET, ali
     return _process('resample_spatial', data=data, resolution=resolution, projection=projection, method=method, align=align)
 
 
+@openeo_process
 def round(x, p=UNSET) -> ProcessBuilder:
     """
     Round to a specified precision
@@ -4428,6 +4717,7 @@ def round(x, p=UNSET) -> ProcessBuilder:
     return _process('round', x=x, p=p)
 
 
+@openeo_process
 def run_udf(data, udf, runtime, version=UNSET, context=UNSET) -> ProcessBuilder:
     """
     Run a UDF
@@ -4445,6 +4735,7 @@ def run_udf(data, udf, runtime, version=UNSET, context=UNSET) -> ProcessBuilder:
     return _process('run_udf', data=data, udf=udf, runtime=runtime, version=version, context=context)
 
 
+@openeo_process
 def run_udf_externally(data, url, context=UNSET) -> ProcessBuilder:
     """
     Run an externally hosted UDF container
@@ -4459,6 +4750,7 @@ def run_udf_externally(data, url, context=UNSET) -> ProcessBuilder:
     return _process('run_udf_externally', data=data, url=url, context=context)
 
 
+@openeo_process
 def sar_backscatter(data, coefficient=UNSET, elevation_model=UNSET, mask=UNSET, contributing_area=UNSET, local_incidence_angle=UNSET, ellipsoid_incidence_angle=UNSET, noise_removal=UNSET, options=UNSET) -> ProcessBuilder:
     """
     Computes backscatter from SAR input
@@ -4490,6 +4782,7 @@ def sar_backscatter(data, coefficient=UNSET, elevation_model=UNSET, mask=UNSET,
     return _process('sar_backscatter', data=data, coefficient=coefficient, elevation_model=elevation_model, mask=mask, contributing_area=contributing_area, local_incidence_angle=local_incidence_angle, ellipsoid_incidence_angle=ellipsoid_incidence_angle, noise_removal=noise_removal, options=options)
 
 
+@openeo_process
 def save_ml_model(data, options=UNSET) -> ProcessBuilder:
     """
     Save a ML model
@@ -4502,6 +4795,7 @@ def save_ml_model(data, options=UNSET) -> ProcessBuilder:
     return _process('save_ml_model', data=data, options=options)
 
 
+@openeo_process
 def save_result(data, format, options=UNSET) -> ProcessBuilder:
     """
     Save processed data
@@ -4520,6 +4814,7 @@ def save_result(data, format, options=UNSET) -> ProcessBuilder:
     return _process('save_result', data=data, format=format, options=options)
 
 
+@openeo_process
 def sd(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Standard deviation
@@ -4533,6 +4828,7 @@ def sd(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('sd', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def sgn(x) -> ProcessBuilder:
     """
     Signum
@@ -4544,6 +4840,7 @@ def sgn(x) -> ProcessBuilder:
     return _process('sgn', x=x)
 
 
+@openeo_process
 def sin(x) -> ProcessBuilder:
     """
     Sine
@@ -4555,6 +4852,7 @@ def sin(x) -> ProcessBuilder:
     return _process('sin', x=x)
 
 
+@openeo_process
 def sinh(x) -> ProcessBuilder:
     """
     Hyperbolic sine
@@ -4566,6 +4864,7 @@ def sinh(x) -> ProcessBuilder:
     return _process('sinh', x=x)
 
 
+@openeo_process
 def sort(data, asc=UNSET, nodata=UNSET) -> ProcessBuilder:
     """
     Sort data
@@ -4581,6 +4880,7 @@ def sort(data, asc=UNSET, nodata=UNSET) -> ProcessBuilder:
     return _process('sort', data=data, asc=asc, nodata=nodata)
 
 
+@openeo_process
 def sqrt(x) -> ProcessBuilder:
     """
     Square root
@@ -4592,6 +4892,7 @@ def sqrt(x) -> ProcessBuilder:
     return _process('sqrt', x=x)
 
 
+@openeo_process
 def subtract(x, y) -> ProcessBuilder:
     """
     Subtraction of two numbers
@@ -4604,6 +4905,7 @@ def subtract(x, y) -> ProcessBuilder:
     return _process('subtract', x=x, y=y)
 
 
+@openeo_process
 def sum(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Compute the sum by adding up numbers
@@ -4617,6 +4919,7 @@ def sum(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('sum', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def tan(x) -> ProcessBuilder:
     """
     Tangent
@@ -4628,6 +4931,7 @@ def tan(x) -> ProcessBuilder:
     return _process('tan', x=x)
 
 
+@openeo_process
 def tanh(x) -> ProcessBuilder:
     """
     Hyperbolic tangent
@@ -4639,6 +4943,7 @@ def tanh(x) -> ProcessBuilder:
     return _process('tanh', x=x)
 
 
+@openeo_process
 def text_begins(data, pattern, case_sensitive=UNSET) -> ProcessBuilder:
     """
     Text begins with another text
@@ -4652,6 +4957,7 @@ def text_begins(data, pattern, case_sensitive=UNSET) -> ProcessBuilder:
     return _process('text_begins', data=data, pattern=pattern, case_sensitive=case_sensitive)
 
 
+@openeo_process
 def text_concat(data, separator=UNSET) -> ProcessBuilder:
     """
     Concatenate elements to a single text
@@ -4666,6 +4972,7 @@ def text_concat(data, separator=UNSET) -> ProcessBuilder:
     return _process('text_concat', data=data, separator=separator)
 
 
+@openeo_process
 def text_contains(data, pattern, case_sensitive=UNSET) -> ProcessBuilder:
     """
     Text contains another text
@@ -4679,6 +4986,7 @@ def text_contains(data, pattern, case_sensitive=UNSET) -> ProcessBuilder:
     return _process('text_contains', data=data, pattern=pattern, case_sensitive=case_sensitive)
 
 
+@openeo_process
 def text_ends(data, pattern, case_sensitive=UNSET) -> ProcessBuilder:
     """
     Text ends with another text
@@ -4692,6 +5000,7 @@ def text_ends(data, pattern, case_sensitive=UNSET) -> ProcessBuilder:
     return _process('text_ends', data=data, pattern=pattern, case_sensitive=case_sensitive)
 
 
+@openeo_process
 def trim_cube(data) -> ProcessBuilder:
     """
     Remove dimension labels with no-data values
@@ -4704,6 +5013,7 @@ def trim_cube(data) -> ProcessBuilder:
     return _process('trim_cube', data=data)
 
 
+@openeo_process
 def unflatten_dimension(data, dimension, target_dimensions, label_separator=UNSET) -> ProcessBuilder:
     """
     Split a single dimensions into multiple dimensions
@@ -4724,6 +5034,7 @@ def unflatten_dimension(data, dimension, target_dimensions, label_separator=UNSE
     return _process('unflatten_dimension', data=data, dimension=dimension, target_dimensions=target_dimensions, label_separator=label_separator)
 
 
+@openeo_process
 def variance(data, ignore_nodata=UNSET) -> ProcessBuilder:
     """
     Variance
@@ -4737,6 +5048,7 @@ def variance(data, ignore_nodata=UNSET) -> ProcessBuilder:
     return _process('variance', data=data, ignore_nodata=ignore_nodata)
 
 
+@openeo_process
 def vector_buffer(geometries, distance) -> ProcessBuilder:
     """
     Buffer geometries by distance
@@ -4754,6 +5066,7 @@ def vector_buffer(geometries, distance) -> ProcessBuilder:
     return _process('vector_buffer', geometries=geometries, distance=distance)
 
 
+@openeo_process
 def vector_to_random_points(data, geometry_count=UNSET, total_count=UNSET, group=UNSET, seed=UNSET) -> ProcessBuilder:
     """
     Sample random points from geometries
@@ -4777,6 +5090,7 @@ def vector_to_random_points(data, geometry_count=UNSET, total_count=UNSET, group
     return _process('vector_to_random_points', data=data, geometry_count=geometry_count, total_count=total_count, group=group, seed=seed)
 
 
+@openeo_process
 def vector_to_regular_points(data, distance, group=UNSET) -> ProcessBuilder:
     """
     Sample regular points from geometries
@@ -4802,6 +5116,7 @@ def vector_to_regular_points(data, distance, group=UNSET) -> ProcessBuilder:
     return _process('vector_to_regular_points', data=data, distance=distance, group=group)
 
 
+@openeo_process
 def xor(x, y) -> ProcessBuilder:
     """
     Logical XOR (exclusive or)
diff --git a/openeo/rest/datacube.py b/openeo/rest/datacube.py
index 87a3f7a0c..f6a9d4e7c 100644
--- a/openeo/rest/datacube.py
+++ b/openeo/rest/datacube.py
@@ -845,7 +845,7 @@ def aggregate_spatial(
             Parameter,
             VectorCube,
         ],
-        reducer: Union[str, PGNode, typing.Callable],
+        reducer: Union[str, typing.Callable, PGNode],
         target_dimension: Optional[str] = None,
         crs: Optional[str] = None,
         context: Optional[dict] = None,
@@ -857,7 +857,20 @@ def aggregate_spatial(
 
         :param geometries: a shapely geometry, a GeoJSON-style dictionary,
             a public GeoJSON URL, or a path (that is valid for the back-end) to a GeoJSON file.
-        :param reducer: a callback function that creates a process graph, see :ref:`callbackfunctions`
+        :param reducer: the "child callback":
+            the name of a single openEO process,
+            or a callback function as discussed in :ref:`callbackfunctions`,
+            or a :py:class:`UDF <openeo.rest._datacube.UDF>` instance.
+
+            The callback should correspond to a process that
+            receives an array of numerical values
+            and returns a single numerical value.
+            For example:
+
+            -   ``"mean"`` (string)
+            -   :py:func:`absolute <openeo.processes.max>` (:ref:`predefined openEO process function <openeo_processes_functions>`)
+            -   ``lambda data: data.min()`` (function or lambda)
+
         :param target_dimension: The new dimension name to be used for storing the results.
         :param crs: The spatial reference system of the provided polygon.
             By default longitude-latitude (EPSG:4326) is assumed.
@@ -931,14 +944,17 @@ def _get_callback(
 
     @openeo_process
     def apply_dimension(
-            self, code: str = None, runtime=None,
-            process: Union[str, PGNode, typing.Callable, UDF] = None,
-            version="latest",
-            # TODO: dimension has no default (per spec)?
-            dimension="t",
-            target_dimension=None,
-            context: Optional[dict] = None,
-    ) -> 'DataCube':
+        self,
+        code: str = None,
+        runtime=None,
+        # TODO: drop None default of process (when `code` and `runtime` args can be dropped)
+        process: Union[str, typing.Callable, UDF, PGNode] = None,
+        version="latest",
+        # TODO: dimension has no default (per spec)?
+        dimension="t",
+        target_dimension=None,
+        context: Optional[dict] = None,
+    ) -> "DataCube":
         """
         Applies a process to all pixel values along a dimension of a raster data cube. For example,
         if the temporal dimension is specified the process will work on a time series of pixel values.
@@ -966,7 +982,21 @@ def apply_dimension(
 
         :param code: [**deprecated**] UDF code or process identifier (optional)
         :param runtime: [**deprecated**] UDF runtime to use (optional)
-        :param process: a callback function that creates a process graph, see :ref:`callbackfunctions`
+        :param process: the "child callback":
+            the name of a single process,
+            or a callback function as discussed in :ref:`callbackfunctions`,
+            or a :py:class:`UDF <openeo.rest._datacube.UDF>` instance.
+
+            The callback should correspond to a process that
+            receives an array of numerical values
+            and returns an array of numerical values.
+            For example:
+
+            -   ``"sort"`` (string)
+            -   :py:func:`sort <openeo.processes.sort>` (:ref:`predefined openEO process function <openeo_processes_functions>`)
+            -   ``lambda data: data.concat([42, -3])`` (function or lambda)
+
+
         :param version: [**deprecated**] Version of the UDF runtime to use
         :param dimension: The name of the source dimension to apply the process on. Fails with a DimensionNotAvailable error if the specified dimension does not exist.
         :param target_dimension: The name of the target dimension or null (the default) to use the source dimension
@@ -1005,17 +1035,31 @@ def apply_dimension(
 
     @openeo_process
     def reduce_dimension(
-            self,
-            dimension: str,
-            reducer: Union[str, PGNode, typing.Callable, UDF],
-            context: Optional[dict] = None,
-            process_id="reduce_dimension", band_math_mode: bool = False
+        self,
+        dimension: str,
+        reducer: Union[str, typing.Callable, UDF, PGNode],
+        context: Optional[dict] = None,
+        process_id="reduce_dimension",
+        band_math_mode: bool = False,
     ) -> "DataCube":
         """
         Add a reduce process with given reducer callback along given dimension
 
         :param dimension: the label of the dimension to reduce
-        :param reducer: "child callback" function, see :ref:`callbackfunctions`
+        :param reducer: the "child callback":
+            the name of a single openEO process,
+            or a callback function as discussed in :ref:`callbackfunctions`,
+            or a :py:class:`UDF <openeo.rest._datacube.UDF>` instance.
+
+            The callback should correspond to a process that
+            receives an array of numerical values
+            and returns a single numerical value.
+            For example:
+
+            -   ``"mean"`` (string)
+            -   :py:func:`absolute <openeo.processes.max>` (:ref:`predefined openEO process function <openeo_processes_functions>`)
+            -   ``lambda data: data.min()`` (function or lambda)
+
         :param context: Additional data to be passed to the process.
         """
         # TODO: check if dimension is valid according to metadata? #116
@@ -1207,15 +1251,27 @@ def apply_neighborhood(
 
     @openeo_process
     def apply(
-            self,
-            process: Union[str, PGNode, typing.Callable, UDF] = None,
-            context: Optional[dict] = None,
+        self,
+        process: Union[str, typing.Callable, UDF, PGNode],
+        context: Optional[dict] = None,
     ) -> "DataCube":
         """
         Applies a unary process (a local operation) to each value of the specified or all dimensions in the data cube.
 
-        :param process: the name of a process, or a callback function that creates a process graph, see :ref:`callbackfunctions`
-        :param dimensions: The names of the dimensions to apply the process on. Defaults to an empty array so that all dimensions are used.
+        :param process: the "child callback":
+            the name of a single process,
+            or a callback function as discussed in :ref:`callbackfunctions`,
+            or a :py:class:`UDF <openeo.rest._datacube.UDF>` instance.
+
+            The callback should correspond to a process that
+            receives a single numerical value
+            and returns a single numerical value.
+            For example:
+
+            -   ``"absolute"`` (string)
+            -   :py:func:`absolute <openeo.processes.absolute>` (:ref:`predefined openEO process function <openeo_processes_functions>`)
+            -   ``lambda x: x * 2 + 3`` (function or lambda)
+
         :param context: Additional data to be passed to the process.
 
         :return: A data cube with the newly computed values. The resolution, cardinality and the number of dimensions are the same as for the original data cube.
@@ -1280,12 +1336,12 @@ def count_time(self) -> "DataCube":
 
     @openeo_process
     def aggregate_temporal(
-            self,
-            intervals: List[list],
-            reducer: Union[str, PGNode, typing.Callable],
-            labels: Optional[List[str]] = None,
-            dimension: Optional[str] = None,
-            context: Optional[dict] = None,
+        self,
+        intervals: List[list],
+        reducer: Union[str, typing.Callable, PGNode],
+        labels: Optional[List[str]] = None,
+        dimension: Optional[str] = None,
+        context: Optional[dict] = None,
     ) -> "DataCube":
         """
         Computes a temporal aggregation based on an array of date and/or time intervals.
@@ -1295,7 +1351,20 @@ def aggregate_temporal(
         If the dimension is not set, the data cube is expected to only have one temporal dimension.
 
         :param intervals: Temporal left-closed intervals so that the start time is contained, but not the end time.
-        :param reducer: A reducer to be applied on all values along the specified dimension. The reducer must be a callable process (or a set processes) that accepts an array and computes a single return value of the same type as the input values, for example median.
+        :param reducer: the "child callback":
+            the name of a single openEO process,
+            or a callback function as discussed in :ref:`callbackfunctions`,
+            or a :py:class:`UDF <openeo.rest._datacube.UDF>` instance.
+
+            The callback should correspond to a process that
+            receives an array of numerical values
+            and returns a single numerical value.
+            For example:
+
+            -   ``"mean"`` (string)
+            -   :py:func:`absolute <openeo.processes.max>` (:ref:`predefined openEO process function <openeo_processes_functions>`)
+            -   ``lambda data: data.min()`` (function or lambda)
+
         :param labels: Labels for the intervals. The number of labels and the number of groups need to be equal.
         :param dimension: The temporal dimension for aggregation. All data along the dimension will be passed through the specified reducer. If the dimension is not set, the data cube is expected to only have one temporal dimension.
         :param context: Additional data to be passed to the reducer. Not set by default.