diff --git a/flink-processor/jar/JMEOS.jar b/flink-processor/jar/JMEOS.jar
index b970140..11520f8 100644
Binary files a/flink-processor/jar/JMEOS.jar and b/flink-processor/jar/JMEOS.jar differ
diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeRgeo.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeRgeo.java
index 0562738..2497d92 100644
--- a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeRgeo.java
+++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeRgeo.java
@@ -18,406 +18,406 @@ public final class MeosOpsFreeRgeo {
     private MeosOpsFreeRgeo() { /* utility */ }
 
     /**
-     * MEOS {@code geo_tpose_to_trgeo} — tier <b>stateless</b>.
+     * MEOS {@code geo_tpose_to_trgeometry} — tier <b>stateless</b>.
      * <p>Pure per-event; safe in any Flink scalar position.</p>
      * <p>Free function (not class-classified). Classification rule: base-type fn, default pure</p>
      */
-    public static jnr.ffi.Pointer geo_tpose_to_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer geo_tpose_to_trgeometry(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "geo_tpose_to_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "geo_tpose_to_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.geo_tpose_to_trgeo(arg0, arg1);
+        return GeneratedFunctions.geo_tpose_to_trgeometry(arg0, arg1);
     }
 
     /**
-     * MEOS {@code teq_geo_trgeo} — tier <b>stateless</b>.
+     * MEOS {@code teq_geo_trgeometry} — tier <b>stateless</b>.
      * <p>Pure per-event; safe in any Flink scalar position.</p>
      * <p>Free function (not class-classified). Classification rule: temporal comparison (per-instant)</p>
      */
-    public static jnr.ffi.Pointer teq_geo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer teq_geo_trgeometry(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "teq_geo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "teq_geo_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.teq_geo_trgeo(arg0, arg1);
+        return GeneratedFunctions.teq_geo_trgeometry(arg0, arg1);
     }
 
     /**
-     * MEOS {@code teq_trgeo_geo} — tier <b>stateless</b>.
+     * MEOS {@code teq_trgeometry_geo} — tier <b>stateless</b>.
      * <p>Pure per-event; safe in any Flink scalar position.</p>
      * <p>Free function (not class-classified). Classification rule: temporal comparison (per-instant)</p>
      */
-    public static jnr.ffi.Pointer teq_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer teq_trgeometry_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "teq_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "teq_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.teq_trgeo_geo(arg0, arg1);
+        return GeneratedFunctions.teq_trgeometry_geo(arg0, arg1);
     }
 
     /**
-     * MEOS {@code tne_geo_trgeo} — tier <b>stateless</b>.
+     * MEOS {@code tne_geo_trgeometry} — tier <b>stateless</b>.
      * <p>Pure per-event; safe in any Flink scalar position.</p>
      * <p>Free function (not class-classified). Classification rule: temporal comparison (per-instant)</p>
      */
-    public static jnr.ffi.Pointer tne_geo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer tne_geo_trgeometry(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "tne_geo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "tne_geo_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.tne_geo_trgeo(arg0, arg1);
+        return GeneratedFunctions.tne_geo_trgeometry(arg0, arg1);
     }
 
     /**
-     * MEOS {@code tne_trgeo_geo} — tier <b>stateless</b>.
+     * MEOS {@code tne_trgeometry_geo} — tier <b>stateless</b>.
      * <p>Pure per-event; safe in any Flink scalar position.</p>
      * <p>Free function (not class-classified). Classification rule: temporal comparison (per-instant)</p>
      */
-    public static jnr.ffi.Pointer tne_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer tne_trgeometry_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "tne_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "tne_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.tne_trgeo_geo(arg0, arg1);
+        return GeneratedFunctions.tne_trgeometry_geo(arg0, arg1);
     }
 
     /**
-     * MEOS {@code nad_stbox_trgeo} — tier <b>bounded-state</b>.
+     * MEOS {@code nad_stbox_trgeometry} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Free function (not class-classified). Classification rule: distance op</p>
      */
-    public static double nad_stbox_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static double nad_stbox_trgeometry(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "nad_stbox_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "nad_stbox_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.nad_stbox_trgeo(arg0, arg1);
+        return GeneratedFunctions.nad_stbox_trgeometry(arg0, arg1);
     }
 
     /**
-     * MEOS {@code nad_trgeo_geo} — tier <b>bounded-state</b>.
+     * MEOS {@code nad_trgeometry_geo} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Free function (not class-classified). Classification rule: distance op</p>
      */
-    public static double nad_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static double nad_trgeometry_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "nad_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "nad_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.nad_trgeo_geo(arg0, arg1);
+        return GeneratedFunctions.nad_trgeometry_geo(arg0, arg1);
     }
 
     /**
-     * MEOS {@code nad_trgeo_stbox} — tier <b>bounded-state</b>.
+     * MEOS {@code nad_trgeometry_stbox} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Free function (not class-classified). Classification rule: distance op</p>
      */
-    public static double nad_trgeo_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static double nad_trgeometry_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "nad_trgeo_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "nad_trgeometry_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.nad_trgeo_stbox(arg0, arg1);
+        return GeneratedFunctions.nad_trgeometry_stbox(arg0, arg1);
     }
 
     /**
-     * MEOS {@code nai_trgeo_geo} — tier <b>bounded-state</b>.
+     * MEOS {@code nai_trgeometry_geo} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Free function (not class-classified). Classification rule: distance op</p>
      */
-    public static jnr.ffi.Pointer nai_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer nai_trgeometry_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "nai_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "nai_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.nai_trgeo_geo(arg0, arg1);
+        return GeneratedFunctions.nai_trgeometry_geo(arg0, arg1);
     }
 
     /**
-     * MEOS {@code shortestline_trgeo_geo} — tier <b>bounded-state</b>.
+     * MEOS {@code shortestline_trgeometry_geo} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Free function (not class-classified). Classification rule: distance op</p>
      */
-    public static jnr.ffi.Pointer shortestline_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer shortestline_trgeometry_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "shortestline_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "shortestline_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.shortestline_trgeo_geo(arg0, arg1);
+        return GeneratedFunctions.shortestline_trgeometry_geo(arg0, arg1);
     }
 
     /**
-     * MEOS {@code tdistance_trgeo_geo} — tier <b>bounded-state</b>.
+     * MEOS {@code tdistance_trgeometry_geo} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Free function (not class-classified). Classification rule: distance op</p>
      */
-    public static jnr.ffi.Pointer tdistance_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer tdistance_trgeometry_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "tdistance_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "tdistance_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.tdistance_trgeo_geo(arg0, arg1);
+        return GeneratedFunctions.tdistance_trgeometry_geo(arg0, arg1);
     }
 
     /**
-     * MEOS {@code always_eq_geo_trgeo} — tier <b>windowed</b>.
+     * MEOS {@code always_eq_geo_trgeometry} — tier <b>windowed</b>.
      * <p>Requires window operator — caller wraps in AggregateFunction.</p>
      * <p>Free function (not class-classified). Classification rule: ever/always over 1 temporal</p>
      */
-    public static int always_eq_geo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static int always_eq_geo_trgeometry(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "always_eq_geo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "always_eq_geo_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.always_eq_geo_trgeo(arg0, arg1);
+        return GeneratedFunctions.always_eq_geo_trgeometry(arg0, arg1);
     }
 
     /**
-     * MEOS {@code always_eq_trgeo_geo} — tier <b>windowed</b>.
+     * MEOS {@code always_eq_trgeometry_geo} — tier <b>windowed</b>.
      * <p>Requires window operator — caller wraps in AggregateFunction.</p>
      * <p>Free function (not class-classified). Classification rule: ever/always over 1 temporal</p>
      */
-    public static int always_eq_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static int always_eq_trgeometry_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "always_eq_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "always_eq_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.always_eq_trgeo_geo(arg0, arg1);
+        return GeneratedFunctions.always_eq_trgeometry_geo(arg0, arg1);
     }
 
     /**
-     * MEOS {@code always_ne_geo_trgeo} — tier <b>windowed</b>.
+     * MEOS {@code always_ne_geo_trgeometry} — tier <b>windowed</b>.
      * <p>Requires window operator — caller wraps in AggregateFunction.</p>
      * <p>Free function (not class-classified). Classification rule: ever/always over 1 temporal</p>
      */
-    public static int always_ne_geo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static int always_ne_geo_trgeometry(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "always_ne_geo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "always_ne_geo_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.always_ne_geo_trgeo(arg0, arg1);
+        return GeneratedFunctions.always_ne_geo_trgeometry(arg0, arg1);
     }
 
     /**
-     * MEOS {@code always_ne_trgeo_geo} — tier <b>windowed</b>.
+     * MEOS {@code always_ne_trgeometry_geo} — tier <b>windowed</b>.
      * <p>Requires window operator — caller wraps in AggregateFunction.</p>
      * <p>Free function (not class-classified). Classification rule: ever/always over 1 temporal</p>
      */
-    public static int always_ne_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static int always_ne_trgeometry_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "always_ne_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "always_ne_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.always_ne_trgeo_geo(arg0, arg1);
+        return GeneratedFunctions.always_ne_trgeometry_geo(arg0, arg1);
     }
 
     /**
-     * MEOS {@code ever_eq_geo_trgeo} — tier <b>windowed</b>.
+     * MEOS {@code ever_eq_geo_trgeometry} — tier <b>windowed</b>.
      * <p>Requires window operator — caller wraps in AggregateFunction.</p>
      * <p>Free function (not class-classified). Classification rule: ever/always over 1 temporal</p>
      */
-    public static int ever_eq_geo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static int ever_eq_geo_trgeometry(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "ever_eq_geo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "ever_eq_geo_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.ever_eq_geo_trgeo(arg0, arg1);
+        return GeneratedFunctions.ever_eq_geo_trgeometry(arg0, arg1);
     }
 
     /**
-     * MEOS {@code ever_eq_trgeo_geo} — tier <b>windowed</b>.
+     * MEOS {@code ever_eq_trgeometry_geo} — tier <b>windowed</b>.
      * <p>Requires window operator — caller wraps in AggregateFunction.</p>
      * <p>Free function (not class-classified). Classification rule: ever/always over 1 temporal</p>
      */
-    public static int ever_eq_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static int ever_eq_trgeometry_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "ever_eq_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "ever_eq_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.ever_eq_trgeo_geo(arg0, arg1);
+        return GeneratedFunctions.ever_eq_trgeometry_geo(arg0, arg1);
     }
 
     /**
-     * MEOS {@code ever_ne_geo_trgeo} — tier <b>windowed</b>.
+     * MEOS {@code ever_ne_geo_trgeometry} — tier <b>windowed</b>.
      * <p>Requires window operator — caller wraps in AggregateFunction.</p>
      * <p>Free function (not class-classified). Classification rule: ever/always over 1 temporal</p>
      */
-    public static int ever_ne_geo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static int ever_ne_geo_trgeometry(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "ever_ne_geo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "ever_ne_geo_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.ever_ne_geo_trgeo(arg0, arg1);
+        return GeneratedFunctions.ever_ne_geo_trgeometry(arg0, arg1);
     }
 
     /**
-     * MEOS {@code ever_ne_trgeo_geo} — tier <b>windowed</b>.
+     * MEOS {@code ever_ne_trgeometry_geo} — tier <b>windowed</b>.
      * <p>Requires window operator — caller wraps in AggregateFunction.</p>
      * <p>Free function (not class-classified). Classification rule: ever/always over 1 temporal</p>
      */
-    public static int ever_ne_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static int ever_ne_trgeometry_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "ever_ne_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "ever_ne_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.ever_ne_trgeo_geo(arg0, arg1);
+        return GeneratedFunctions.ever_ne_trgeometry_geo(arg0, arg1);
     }
 
     /**
-     * MEOS {@code always_eq_trgeo_trgeo} — tier <b>cross-stream</b>.
+     * MEOS {@code always_eq_trgeometry_trgeometry} — tier <b>cross-stream</b>.
      * <p>Pairwise across streams — caller wraps in a join.</p>
      * <p>Free function (not class-classified). Classification rule: ever/always over 2 temporals</p>
      */
-    public static int always_eq_trgeo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static int always_eq_trgeometry_trgeometry(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "always_eq_trgeo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "always_eq_trgeometry_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.always_eq_trgeo_trgeo(arg0, arg1);
+        return GeneratedFunctions.always_eq_trgeometry_trgeometry(arg0, arg1);
     }
 
     /**
-     * MEOS {@code always_ne_trgeo_trgeo} — tier <b>cross-stream</b>.
+     * MEOS {@code always_ne_trgeometry_trgeometry} — tier <b>cross-stream</b>.
      * <p>Pairwise across streams — caller wraps in a join.</p>
      * <p>Free function (not class-classified). Classification rule: ever/always over 2 temporals</p>
      */
-    public static int always_ne_trgeo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static int always_ne_trgeometry_trgeometry(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "always_ne_trgeo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "always_ne_trgeometry_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.always_ne_trgeo_trgeo(arg0, arg1);
+        return GeneratedFunctions.always_ne_trgeometry_trgeometry(arg0, arg1);
     }
 
     /**
-     * MEOS {@code ever_eq_trgeo_trgeo} — tier <b>cross-stream</b>.
+     * MEOS {@code ever_eq_trgeometry_trgeometry} — tier <b>cross-stream</b>.
      * <p>Pairwise across streams — caller wraps in a join.</p>
      * <p>Free function (not class-classified). Classification rule: ever/always over 2 temporals</p>
      */
-    public static int ever_eq_trgeo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static int ever_eq_trgeometry_trgeometry(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "ever_eq_trgeo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "ever_eq_trgeometry_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.ever_eq_trgeo_trgeo(arg0, arg1);
+        return GeneratedFunctions.ever_eq_trgeometry_trgeometry(arg0, arg1);
     }
 
     /**
-     * MEOS {@code ever_ne_trgeo_trgeo} — tier <b>cross-stream</b>.
+     * MEOS {@code ever_ne_trgeometry_trgeometry} — tier <b>cross-stream</b>.
      * <p>Pairwise across streams — caller wraps in a join.</p>
      * <p>Free function (not class-classified). Classification rule: ever/always over 2 temporals</p>
      */
-    public static int ever_ne_trgeo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static int ever_ne_trgeometry_trgeometry(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "ever_ne_trgeo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "ever_ne_trgeometry_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.ever_ne_trgeo_trgeo(arg0, arg1);
+        return GeneratedFunctions.ever_ne_trgeometry_trgeometry(arg0, arg1);
     }
 
     /**
-     * MEOS {@code nad_trgeo_tpoint} — tier <b>cross-stream</b>.
+     * MEOS {@code nad_trgeometry_tpoint} — tier <b>cross-stream</b>.
      * <p>Pairwise across streams — caller wraps in a join.</p>
      * <p>Free function (not class-classified). Classification rule: distance on 2 temporals</p>
      */
-    public static double nad_trgeo_tpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static double nad_trgeometry_tpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "nad_trgeo_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "nad_trgeometry_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.nad_trgeo_tpoint(arg0, arg1);
+        return GeneratedFunctions.nad_trgeometry_tpoint(arg0, arg1);
     }
 
     /**
-     * MEOS {@code nad_trgeo_trgeo} — tier <b>cross-stream</b>.
+     * MEOS {@code nad_trgeometry_trgeometry} — tier <b>cross-stream</b>.
      * <p>Pairwise across streams — caller wraps in a join.</p>
      * <p>Free function (not class-classified). Classification rule: distance on 2 temporals</p>
      */
-    public static double nad_trgeo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static double nad_trgeometry_trgeometry(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "nad_trgeo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "nad_trgeometry_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.nad_trgeo_trgeo(arg0, arg1);
+        return GeneratedFunctions.nad_trgeometry_trgeometry(arg0, arg1);
     }
 
     /**
-     * MEOS {@code nai_trgeo_tpoint} — tier <b>cross-stream</b>.
+     * MEOS {@code nai_trgeometry_tpoint} — tier <b>cross-stream</b>.
      * <p>Pairwise across streams — caller wraps in a join.</p>
      * <p>Free function (not class-classified). Classification rule: distance on 2 temporals</p>
      */
-    public static jnr.ffi.Pointer nai_trgeo_tpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer nai_trgeometry_tpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "nai_trgeo_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "nai_trgeometry_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.nai_trgeo_tpoint(arg0, arg1);
+        return GeneratedFunctions.nai_trgeometry_tpoint(arg0, arg1);
     }
 
     /**
-     * MEOS {@code nai_trgeo_trgeo} — tier <b>cross-stream</b>.
+     * MEOS {@code nai_trgeometry_trgeometry} — tier <b>cross-stream</b>.
      * <p>Pairwise across streams — caller wraps in a join.</p>
      * <p>Free function (not class-classified). Classification rule: distance on 2 temporals</p>
      */
-    public static jnr.ffi.Pointer nai_trgeo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer nai_trgeometry_trgeometry(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "nai_trgeo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "nai_trgeometry_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.nai_trgeo_trgeo(arg0, arg1);
+        return GeneratedFunctions.nai_trgeometry_trgeometry(arg0, arg1);
     }
 
     /**
-     * MEOS {@code shortestline_trgeo_tpoint} — tier <b>cross-stream</b>.
+     * MEOS {@code shortestline_trgeometry_tpoint} — tier <b>cross-stream</b>.
      * <p>Pairwise across streams — caller wraps in a join.</p>
      * <p>Free function (not class-classified). Classification rule: distance on 2 temporals</p>
      */
-    public static jnr.ffi.Pointer shortestline_trgeo_tpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer shortestline_trgeometry_tpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "shortestline_trgeo_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "shortestline_trgeometry_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.shortestline_trgeo_tpoint(arg0, arg1);
+        return GeneratedFunctions.shortestline_trgeometry_tpoint(arg0, arg1);
     }
 
     /**
-     * MEOS {@code shortestline_trgeo_trgeo} — tier <b>cross-stream</b>.
+     * MEOS {@code shortestline_trgeometry_trgeometry} — tier <b>cross-stream</b>.
      * <p>Pairwise across streams — caller wraps in a join.</p>
      * <p>Free function (not class-classified). Classification rule: distance on 2 temporals</p>
      */
-    public static jnr.ffi.Pointer shortestline_trgeo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer shortestline_trgeometry_trgeometry(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "shortestline_trgeo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "shortestline_trgeometry_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.shortestline_trgeo_trgeo(arg0, arg1);
+        return GeneratedFunctions.shortestline_trgeometry_trgeometry(arg0, arg1);
     }
 
     /**
-     * MEOS {@code tdistance_trgeo_tpoint} — tier <b>cross-stream</b>.
+     * MEOS {@code tdistance_trgeometry_tpoint} — tier <b>cross-stream</b>.
      * <p>Pairwise across streams — caller wraps in a join.</p>
      * <p>Free function (not class-classified). Classification rule: distance on 2 temporals</p>
      */
-    public static jnr.ffi.Pointer tdistance_trgeo_tpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer tdistance_trgeometry_tpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "tdistance_trgeo_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "tdistance_trgeometry_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.tdistance_trgeo_tpoint(arg0, arg1);
+        return GeneratedFunctions.tdistance_trgeometry_tpoint(arg0, arg1);
     }
 
     /**
-     * MEOS {@code tdistance_trgeo_trgeo} — tier <b>cross-stream</b>.
+     * MEOS {@code tdistance_trgeometry_trgeometry} — tier <b>cross-stream</b>.
      * <p>Pairwise across streams — caller wraps in a join.</p>
      * <p>Free function (not class-classified). Classification rule: distance on 2 temporals</p>
      */
-    public static jnr.ffi.Pointer tdistance_trgeo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer tdistance_trgeometry_trgeometry(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "tdistance_trgeo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "tdistance_trgeometry_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.tdistance_trgeo_trgeo(arg0, arg1);
+        return GeneratedFunctions.tdistance_trgeometry_trgeometry(arg0, arg1);
     }
 
 }
diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTRGeometry.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTRGeometry.java
index ce92704..8ed2ac7 100644
--- a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTRGeometry.java
+++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTRGeometry.java
@@ -16,507 +16,507 @@ public final class MeosOpsTRGeometry {
     private MeosOpsTRGeometry() { /* utility */ }
 
     /**
-     * MEOS {@code trgeo_to_tinstant} — tier <b>stateless</b>.
+     * MEOS {@code trgeometry_to_tinstant} — tier <b>stateless</b>.
      * <p>Pure per-event; safe in any Flink scalar position.</p>
      * <p>Object-model role: {@code conversion}.</p>
      * <p>Classification: role=conversion</p>
      */
-    public static jnr.ffi.Pointer trgeo_to_tinstant(jnr.ffi.Pointer arg0) {
+    public static jnr.ffi.Pointer trgeometry_to_tinstant(jnr.ffi.Pointer arg0) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_to_tinstant requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_to_tinstant requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_to_tinstant(arg0);
+        return GeneratedFunctions.trgeometry_to_tinstant(arg0);
     }
 
     /**
-     * MEOS {@code trgeo_to_tpoint} — tier <b>stateless</b>.
+     * MEOS {@code trgeometry_to_tpoint} — tier <b>stateless</b>.
      * <p>Pure per-event; safe in any Flink scalar position.</p>
      * <p>Object-model role: {@code conversion}.</p>
      * <p>Classification: role=conversion</p>
      */
-    public static jnr.ffi.Pointer trgeo_to_tpoint(jnr.ffi.Pointer arg0) {
+    public static jnr.ffi.Pointer trgeometry_to_tpoint(jnr.ffi.Pointer arg0) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_to_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_to_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_to_tpoint(arg0);
+        return GeneratedFunctions.trgeometry_to_tpoint(arg0);
     }
 
     /**
-     * MEOS {@code trgeo_to_tpose} — tier <b>stateless</b>.
+     * MEOS {@code trgeometry_to_tpose} — tier <b>stateless</b>.
      * <p>Pure per-event; safe in any Flink scalar position.</p>
      * <p>Object-model role: {@code conversion}.</p>
      * <p>Classification: role=conversion</p>
      */
-    public static jnr.ffi.Pointer trgeo_to_tpose(jnr.ffi.Pointer arg0) {
+    public static jnr.ffi.Pointer trgeometry_to_tpose(jnr.ffi.Pointer arg0) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_to_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_to_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_to_tpose(arg0);
+        return GeneratedFunctions.trgeometry_to_tpose(arg0);
     }
 
     /**
-     * MEOS {@code trgeo_after_timestamptz} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_after_timestamptz} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_after_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) {
+    public static jnr.ffi.Pointer trgeometry_after_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_after_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_after_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_after_timestamptz(arg0, arg1, arg2);
+        return GeneratedFunctions.trgeometry_after_timestamptz(arg0, arg1, arg2);
     }
 
     /**
-     * MEOS {@code trgeo_append_tinstant} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_append_tinstant} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_append_tinstant(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2, double arg3, jnr.ffi.Pointer arg4, boolean arg5) {
+    public static jnr.ffi.Pointer trgeometry_append_tinstant(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2, double arg3, jnr.ffi.Pointer arg4, boolean arg5) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_append_tinstant requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_append_tinstant requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_append_tinstant(arg0, arg1, arg2, arg3, arg4, arg5);
+        return GeneratedFunctions.trgeometry_append_tinstant(arg0, arg1, arg2, arg3, arg4, arg5);
     }
 
     /**
-     * MEOS {@code trgeo_append_tsequence} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_append_tsequence} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_append_tsequence(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
+    public static jnr.ffi.Pointer trgeometry_append_tsequence(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_append_tsequence requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_append_tsequence requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_append_tsequence(arg0, arg1, arg2);
+        return GeneratedFunctions.trgeometry_append_tsequence(arg0, arg1, arg2);
     }
 
     /**
-     * MEOS {@code trgeo_before_timestamptz} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_before_timestamptz} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_before_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) {
+    public static jnr.ffi.Pointer trgeometry_before_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_before_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_before_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_before_timestamptz(arg0, arg1, arg2);
+        return GeneratedFunctions.trgeometry_before_timestamptz(arg0, arg1, arg2);
     }
 
     /**
-     * MEOS {@code trgeo_delete_timestamptz} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_delete_timestamptz} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_delete_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) {
+    public static jnr.ffi.Pointer trgeometry_delete_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_delete_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_delete_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_delete_timestamptz(arg0, arg1, arg2);
+        return GeneratedFunctions.trgeometry_delete_timestamptz(arg0, arg1, arg2);
     }
 
     /**
-     * MEOS {@code trgeo_delete_tstzset} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_delete_tstzset} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_delete_tstzset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
+    public static jnr.ffi.Pointer trgeometry_delete_tstzset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_delete_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_delete_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_delete_tstzset(arg0, arg1, arg2);
+        return GeneratedFunctions.trgeometry_delete_tstzset(arg0, arg1, arg2);
     }
 
     /**
-     * MEOS {@code trgeo_delete_tstzspan} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_delete_tstzspan} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_delete_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
+    public static jnr.ffi.Pointer trgeometry_delete_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_delete_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_delete_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_delete_tstzspan(arg0, arg1, arg2);
+        return GeneratedFunctions.trgeometry_delete_tstzspan(arg0, arg1, arg2);
     }
 
     /**
-     * MEOS {@code trgeo_delete_tstzspanset} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_delete_tstzspanset} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_delete_tstzspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
+    public static jnr.ffi.Pointer trgeometry_delete_tstzspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_delete_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_delete_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_delete_tstzspanset(arg0, arg1, arg2);
+        return GeneratedFunctions.trgeometry_delete_tstzspanset(arg0, arg1, arg2);
     }
 
     /**
-     * MEOS {@code trgeo_end_instant} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_end_instant} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_end_instant(jnr.ffi.Pointer arg0) {
+    public static jnr.ffi.Pointer trgeometry_end_instant(jnr.ffi.Pointer arg0) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_end_instant requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_end_instant requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_end_instant(arg0);
+        return GeneratedFunctions.trgeometry_end_instant(arg0);
     }
 
     /**
-     * MEOS {@code trgeo_end_sequence} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_end_sequence} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_end_sequence(jnr.ffi.Pointer arg0) {
+    public static jnr.ffi.Pointer trgeometry_end_sequence(jnr.ffi.Pointer arg0) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_end_sequence requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_end_sequence requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_end_sequence(arg0);
+        return GeneratedFunctions.trgeometry_end_sequence(arg0);
     }
 
     /**
-     * MEOS {@code trgeo_end_value} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_end_value} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_end_value(jnr.ffi.Pointer arg0) {
+    public static jnr.ffi.Pointer trgeometry_end_value(jnr.ffi.Pointer arg0) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_end_value(arg0);
+        return GeneratedFunctions.trgeometry_end_value(arg0);
     }
 
     /**
-     * MEOS {@code trgeo_geom} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_geom} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_geom(jnr.ffi.Pointer arg0) {
+    public static jnr.ffi.Pointer trgeometry_geom(jnr.ffi.Pointer arg0) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_geom requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_geom requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_geom(arg0);
+        return GeneratedFunctions.trgeometry_geom(arg0);
     }
 
     /**
-     * MEOS {@code trgeo_instant_n} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_instant_n} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_instant_n(jnr.ffi.Pointer arg0, int arg1) {
+    public static jnr.ffi.Pointer trgeometry_instant_n(jnr.ffi.Pointer arg0, int arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_instant_n requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_instant_n requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_instant_n(arg0, arg1);
+        return GeneratedFunctions.trgeometry_instant_n(arg0, arg1);
     }
 
     /**
-     * MEOS {@code trgeo_instants} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_instants} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_instants(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer trgeometry_instants(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_instants requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_instants requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_instants(arg0, arg1);
+        return GeneratedFunctions.trgeometry_instants(arg0, arg1);
     }
 
     /**
-     * MEOS {@code trgeo_points} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_points} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_points(jnr.ffi.Pointer arg0) {
+    public static jnr.ffi.Pointer trgeometry_points(jnr.ffi.Pointer arg0) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_points requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_points requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_points(arg0);
+        return GeneratedFunctions.trgeometry_points(arg0);
     }
 
     /**
-     * MEOS {@code trgeo_restrict_timestamptz} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_restrict_timestamptz} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_restrict_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) {
+    public static jnr.ffi.Pointer trgeometry_restrict_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_restrict_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_restrict_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_restrict_timestamptz(arg0, arg1, arg2);
+        return GeneratedFunctions.trgeometry_restrict_timestamptz(arg0, arg1, arg2);
     }
 
     /**
-     * MEOS {@code trgeo_restrict_tstzset} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_restrict_tstzset} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_restrict_tstzset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
+    public static jnr.ffi.Pointer trgeometry_restrict_tstzset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_restrict_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_restrict_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_restrict_tstzset(arg0, arg1, arg2);
+        return GeneratedFunctions.trgeometry_restrict_tstzset(arg0, arg1, arg2);
     }
 
     /**
-     * MEOS {@code trgeo_restrict_tstzspan} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_restrict_tstzspan} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_restrict_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
+    public static jnr.ffi.Pointer trgeometry_restrict_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_restrict_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_restrict_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_restrict_tstzspan(arg0, arg1, arg2);
+        return GeneratedFunctions.trgeometry_restrict_tstzspan(arg0, arg1, arg2);
     }
 
     /**
-     * MEOS {@code trgeo_restrict_tstzspanset} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_restrict_tstzspanset} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_restrict_tstzspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
+    public static jnr.ffi.Pointer trgeometry_restrict_tstzspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_restrict_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_restrict_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_restrict_tstzspanset(arg0, arg1, arg2);
+        return GeneratedFunctions.trgeometry_restrict_tstzspanset(arg0, arg1, arg2);
     }
 
     /**
-     * MEOS {@code trgeo_restrict_value} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_restrict_value} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_restrict_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
+    public static jnr.ffi.Pointer trgeometry_restrict_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_restrict_value requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_restrict_value requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_restrict_value(arg0, arg1, arg2);
+        return GeneratedFunctions.trgeometry_restrict_value(arg0, arg1, arg2);
     }
 
     /**
-     * MEOS {@code trgeo_restrict_values} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_restrict_values} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_restrict_values(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
+    public static jnr.ffi.Pointer trgeometry_restrict_values(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_restrict_values requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_restrict_values requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_restrict_values(arg0, arg1, arg2);
+        return GeneratedFunctions.trgeometry_restrict_values(arg0, arg1, arg2);
     }
 
     /**
-     * MEOS {@code trgeo_rotation} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_rotation} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_rotation(jnr.ffi.Pointer arg0) {
+    public static jnr.ffi.Pointer trgeometry_rotation(jnr.ffi.Pointer arg0) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_rotation requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_rotation requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_rotation(arg0);
+        return GeneratedFunctions.trgeometry_rotation(arg0);
     }
 
     /**
-     * MEOS {@code trgeo_round} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_round} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_round(jnr.ffi.Pointer arg0, int arg1) {
+    public static jnr.ffi.Pointer trgeometry_round(jnr.ffi.Pointer arg0, int arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_round requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_round requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_round(arg0, arg1);
+        return GeneratedFunctions.trgeometry_round(arg0, arg1);
     }
 
     /**
-     * MEOS {@code trgeo_segments} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_segments} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_segments(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer trgeometry_segments(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_segments requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_segments requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_segments(arg0, arg1);
+        return GeneratedFunctions.trgeometry_segments(arg0, arg1);
     }
 
     /**
-     * MEOS {@code trgeo_sequence_n} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_sequence_n} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_sequence_n(jnr.ffi.Pointer arg0, int arg1) {
+    public static jnr.ffi.Pointer trgeometry_sequence_n(jnr.ffi.Pointer arg0, int arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_sequence_n requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_sequence_n requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_sequence_n(arg0, arg1);
+        return GeneratedFunctions.trgeometry_sequence_n(arg0, arg1);
     }
 
     /**
-     * MEOS {@code trgeo_sequences} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_sequences} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_sequences(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
+    public static jnr.ffi.Pointer trgeometry_sequences(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_sequences requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_sequences requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_sequences(arg0, arg1);
+        return GeneratedFunctions.trgeometry_sequences(arg0, arg1);
     }
 
     /**
-     * MEOS {@code trgeo_set_interp} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_set_interp} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_set_interp(jnr.ffi.Pointer arg0, int arg1) {
+    public static jnr.ffi.Pointer trgeometry_set_interp(jnr.ffi.Pointer arg0, int arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_set_interp requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_set_interp requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_set_interp(arg0, arg1);
+        return GeneratedFunctions.trgeometry_set_interp(arg0, arg1);
     }
 
     /**
-     * MEOS {@code trgeo_start_instant} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_start_instant} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_start_instant(jnr.ffi.Pointer arg0) {
+    public static jnr.ffi.Pointer trgeometry_start_instant(jnr.ffi.Pointer arg0) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_start_instant requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_start_instant requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_start_instant(arg0);
+        return GeneratedFunctions.trgeometry_start_instant(arg0);
     }
 
     /**
-     * MEOS {@code trgeo_start_sequence} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_start_sequence} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_start_sequence(jnr.ffi.Pointer arg0) {
+    public static jnr.ffi.Pointer trgeometry_start_sequence(jnr.ffi.Pointer arg0) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_start_sequence requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_start_sequence requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_start_sequence(arg0);
+        return GeneratedFunctions.trgeometry_start_sequence(arg0);
     }
 
     /**
-     * MEOS {@code trgeo_start_value} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_start_value} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_start_value(jnr.ffi.Pointer arg0) {
+    public static jnr.ffi.Pointer trgeometry_start_value(jnr.ffi.Pointer arg0) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_start_value(arg0);
+        return GeneratedFunctions.trgeometry_start_value(arg0);
     }
 
     /**
-     * MEOS {@code trgeo_traversed_area} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_traversed_area} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_traversed_area(jnr.ffi.Pointer arg0, boolean arg1) {
+    public static jnr.ffi.Pointer trgeometry_traversed_area(jnr.ffi.Pointer arg0, boolean arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_traversed_area requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_traversed_area requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_traversed_area(arg0, arg1);
+        return GeneratedFunctions.trgeometry_traversed_area(arg0, arg1);
     }
 
     /**
-     * MEOS {@code trgeo_value_n} — tier <b>bounded-state</b>.
+     * MEOS {@code trgeometry_value_n} — tier <b>bounded-state</b>.
      * <p>Per-event with bounded per-key state (MEOS handle).</p>
      * <p>Object-model role: {@code accessor}.</p>
      * <p>Classification: role=accessor</p>
      */
-    public static jnr.ffi.Pointer trgeo_value_n(jnr.ffi.Pointer arg0, int arg1) {
+    public static jnr.ffi.Pointer trgeometry_value_n(jnr.ffi.Pointer arg0, int arg1) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_value_n(arg0, arg1);
+        return GeneratedFunctions.trgeometry_value_n(arg0, arg1);
     }
 
     /**
-     * MEOS {@code trgeo_out} — tier <b>io-meta</b>.
+     * MEOS {@code trgeometry_out} — tier <b>io-meta</b>.
      * <p>I/O / catalog / lifecycle helper.</p>
      * <p>Object-model role: {@code output}.</p>
      * <p>Classification: IO/serialization</p>
      */
-    public static java.lang.String trgeo_out(jnr.ffi.Pointer arg0) {
+    public static java.lang.String trgeometry_out(jnr.ffi.Pointer arg0) {
         if (!MEOS_AVAILABLE) {
             throw new UnsupportedOperationException(
-                "trgeo_out requires libmeos — set -Dmobilityflink.meos.enabled=true");
+                "trgeometry_out requires libmeos — set -Dmobilityflink.meos.enabled=true");
         }
-        return GeneratedFunctions.trgeo_out(arg0);
+        return GeneratedFunctions.trgeometry_out(arg0);
     }
 
 }