diff --git a/Dockerfile b/Dockerfile
index b584255..51c2088 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -99,6 +99,122 @@ RUN mkdir -p build && cd build \
     && cp /root/json-c/build/*.h /root/json-c-install/include/json-c/ \
     && cp /root/json-c/build/libjson-c.a /root/json-c-install/lib/
 
+# COMPILING ZLIB WITH EMSCRIPTEN
+#
+# pgPointCloud's libpc links zlib and libxml2, so POINTCLOUD needs both on the
+# wasm build path. Emscripten ships a zlib port, but MEOS reaches it through
+# find_package(ZLIB), which wants a prefix it can point at rather than a linker
+# flag, so it is built here like every other dependency.
+FROM base AS zlib
+
+RUN curl -fL "https://github.com/madler/zlib/releases/download/v1.3.1/zlib-1.3.1.tar.gz" \
+        | tar xz -C /root \
+    && mv /root/zlib-1.3.1 /root/zlib
+
+WORKDIR /root/zlib
+RUN mkdir -p build && cd build \
+    && emcmake cmake .. \
+        -DCMAKE_BUILD_TYPE=Release \
+        -DCMAKE_INSTALL_PREFIX=/root/zlib-install \
+        -DBUILD_SHARED_LIBS=OFF \
+        -DZLIB_BUILD_EXAMPLES=OFF \
+        -DCMAKE_C_FLAGS=-sMEMORY64=1 \
+    && emmake make -j"$(nproc)" zlibstatic \
+    && emmake make install
+
+# COMPILING LIBXML2 WITH EMSCRIPTEN
+#
+# The other half of libpc's link line. Every optional feature is off: libpc uses
+# libxml2 to read a point cloud's XML schema, so the parser is all that is
+# needed, and the extras (python, http, lzma, iconv) each drag in a dependency
+# this image would then have to cross-compile too.
+FROM base AS libxml2
+
+COPY --from=zlib /root/zlib-install /root/zlib-install
+
+RUN curl -fL "https://download.gnome.org/sources/libxml2/2.13/libxml2-2.13.5.tar.xz" \
+        | tar xJ -C /root \
+    && mv /root/libxml2-2.13.5 /root/libxml2
+
+WORKDIR /root/libxml2
+RUN mkdir -p build && cd build \
+    && emcmake cmake .. \
+        -DCMAKE_BUILD_TYPE=Release \
+        -DCMAKE_INSTALL_PREFIX=/root/libxml2-install \
+        -DZLIB_INCLUDE_DIR=/root/zlib-install/include \
+        -DZLIB_LIBRARY=/root/zlib-install/lib/libz.a \
+        -DBUILD_SHARED_LIBS=OFF \
+        -DLIBXML2_WITH_PYTHON=OFF \
+        -DLIBXML2_WITH_HTTP=OFF \
+        -DLIBXML2_WITH_LZMA=OFF \
+        -DLIBXML2_WITH_ICONV=OFF \
+        -DLIBXML2_WITH_ZLIB=ON \
+        -DLIBXML2_WITH_PROGRAMS=OFF \
+        -DLIBXML2_WITH_TESTS=OFF \
+        -DCMAKE_C_FLAGS=-sMEMORY64=1 \
+    && emmake make -j"$(nproc)" \
+    && emmake make install
+
+# COMPILING GDAL WITH EMSCRIPTEN
+#
+# RASTER samples raster bands along a trajectory through GDAL, and -DALL=ON turns
+# RASTER on, so GDAL has to be on the wasm build path for the family set
+# MobilityDB's own CMakeLists defines.
+#
+# Every optional driver is off. GDAL's driver set is where its bulk and its
+# dependency surface live (curl, netcdf, hdf5, the proprietary SDKs), and MEOS
+# reads raster bands through the generic API rather than naming a format, so the
+# core plus the built-in drivers is the whole requirement. The dependencies it
+# does take — PROJ and SQLite — are ones this image already builds for MEOS
+# itself, so GDAL adds no third-party library that was not already here.
+#
+# GEOS is off in GDAL: it backs OGR's geometry predicates, which raster band
+# sampling does not reach, and MEOS links its own GEOS regardless. Handing it
+# this tree's GEOS would also need two include directories — `geos_c.h` takes
+# `geos/export.h` from the source tree while the header itself is generated into
+# the build tree — and GEOS_INCLUDE_DIR names one.
+FROM base AS gdal
+
+COPY --from=sqlite /root/sqlite3 /root/sqlite3
+COPY --from=proj   /root/PROJ    /root/PROJ
+COPY --from=geos   /root/geos    /root/geos
+COPY --from=zlib   /root/zlib-install /root/zlib-install
+
+RUN curl -fL "https://github.com/OSGeo/gdal/releases/download/v3.9.3/gdal-3.9.3.tar.gz" \
+        | tar xz -C /root \
+    && mv /root/gdal-3.9.3 /root/gdal
+
+WORKDIR /root/gdal
+RUN mkdir -p build && cd build \
+    && emcmake cmake .. \
+        -DCMAKE_BUILD_TYPE=Release \
+        -DCMAKE_INSTALL_PREFIX=/root/gdal-install \
+        -DBUILD_SHARED_LIBS=OFF \
+        -DBUILD_APPS=OFF \
+        -DBUILD_TESTING=OFF \
+        -DBUILD_DOCS=OFF \
+        -DBUILD_PYTHON_BINDINGS=OFF \
+        -DBUILD_JAVA_BINDINGS=OFF \
+        -DBUILD_CSHARP_BINDINGS=OFF \
+        -DGDAL_BUILD_OPTIONAL_DRIVERS=OFF \
+        -DOGR_BUILD_OPTIONAL_DRIVERS=OFF \
+        -DGDAL_USE_EXTERNAL_LIBS=OFF \
+        -DGDAL_USE_INTERNAL_LIBS=ON \
+        -DGDAL_USE_PROJ=ON \
+        -DPROJ_INCLUDE_DIR=/root/PROJ/src \
+        -DPROJ_LIBRARY=/root/PROJ/build/lib/libproj.a \
+        -DGDAL_USE_GEOS=OFF \
+        -DGDAL_USE_SQLITE3=ON \
+        -DSQLite3_INCLUDE_DIR=/root/sqlite3 \
+        -DSQLite3_LIBRARY=/root/sqlite3/libsqlite3.a \
+        -DGDAL_USE_ZLIB=ON \
+        -DZLIB_INCLUDE_DIR=/root/zlib-install/include \
+        -DZLIB_LIBRARY=/root/zlib-install/lib/libz.a \
+        -DCMAKE_C_FLAGS=-sMEMORY64=1 \
+        -DCMAKE_CXX_FLAGS=-sMEMORY64=1 \
+    && emmake make -j"$(nproc)" \
+    && emmake make install
+
 # COMPILING GSL WITH EMSCRIPTEN
 FROM base AS gsl
 
@@ -163,6 +279,9 @@ COPY --from=proj           /root/PROJ            /root/PROJ
 COPY --from=jsonc          /root/json-c-install  /root/json-c-install
 COPY --from=gsl            /root/gsl-wasm        /root/gsl-wasm
 COPY --from=h3             /root/h3-install      /root/h3-install
+COPY --from=zlib           /root/zlib-install    /root/zlib-install
+COPY --from=libxml2        /root/libxml2-install /root/libxml2-install
+COPY --from=gdal           /root/gdal-install    /root/gdal-install
 COPY --from=mobilitydb_src /root/MobilityDB      /root/MobilityDB
 
 WORKDIR /app
@@ -176,16 +295,17 @@ WORKDIR /app
 COPY . .
 
 # CMAKE: configure MobilityDB
+#
+# The install prefix is named HERE, not only on the install line: `meos.pc` is
+# generated at configure time and records the prefix it is given then, so a
+# prefix supplied later relocates the files while the `.pc` keeps pointing at
+# the emscripten sysroot, and `pkg-config --cflags` then reports an include
+# directory that holds no MEOS header.
 RUN INCLUDES="-I/root/geos/include -I/root/geos/build/capi -I/root/json-c-install/include -I/root/json-c-install/include/json-c" \
     && emcmake cmake -S /root/MobilityDB -B /root/MobilityDB/build \
         -DMEOS=ON \
-        -DCBUFFER=ON \
-        -DNPOINT=ON \
-        -DPOSE=ON \
-        -DRGEO=ON \
-        -DH3=ON \
-        -DJSON=ON \
-        -DQUADBIN=ON \
+        -DALL=ON \
+        -DCMAKE_INSTALL_PREFIX=/root/meos-install \
         -DH3_LIBRARY=/root/h3-install/lib/libh3.a \
         -DH3_INCLUDE_DIR=/root/h3-install/include \
         -DBUILD_SHARED_LIBS=OFF \
@@ -199,6 +319,12 @@ RUN INCLUDES="-I/root/geos/include -I/root/geos/build/capi -I/root/json-c-instal
         -DGSL_INCLUDE_DIR=/root/gsl-wasm/include \
         -DGSL_LIBRARY=/root/gsl-wasm/lib/libgsl.a \
         -DGSL_CBLAS_LIBRARY=/root/gsl-wasm/lib/libgslcblas.a \
+        -DZLIB_INCLUDE_DIR=/root/zlib-install/include \
+        -DZLIB_LIBRARY=/root/zlib-install/lib/libz.a \
+        -DLIBXML2_INCLUDE_DIR=/root/libxml2-install/include/libxml2 \
+        -DLIBXML2_LIBRARY=/root/libxml2-install/lib/libxml2.a \
+        -DGDAL_INCLUDE_DIR=/root/gdal-install/include \
+        -DGDAL_LIBRARY=/root/gdal-install/lib/libgdal.a \
         "-DCMAKE_C_FLAGS=-sMEMORY64=1 $INCLUDES" \
         "-DCMAKE_CXX_FLAGS=-sMEMORY64=1 $INCLUDES"
 
@@ -264,8 +390,23 @@ RUN cmake --build /root/MobilityDB/build --target meos --parallel "$(nproc)" \
 #     8 MB is reserved address space, not committed RAM, so it is cheap and
 #     pushes the practical limit from ~2500 to hundreds of thousands of
 #     instants.
+#
+# The installed MEOS describes itself: `pkg-config --cflags meos` reports its
+# include directory together with the family macros it is compiled with. Both
+# halves matter, because the public headers gate declarations on those macros --
+# `meos.h` holds `#if POINTCLOUD` and `#if JSON` blocks -- so an include path
+# written here without them compiles the negative branch and loses declarations
+# whose symbols the archive exports.
+#
+# EMULATE_FUNCTION_POINTER_CASTS makes wasm-opt give every indirect call one
+# signature, as wide as the widest function type in the module, and it refuses
+# to run when that exceeds its default cap. GDAL, which RASTER samples raster
+# bands through, carries the widest of them. The pass names the minimum it needs
+# in its own error, and the value is kept at that minimum because the width it
+# sets is paid by every thunk.
 RUN mkdir -p /app/wasm \
     && emcc -sMEMORY64=1 -sEMULATE_FUNCTION_POINTER_CASTS=1 -O1 \
+        -sBINARYEN_EXTRA_PASSES=pass-arg=max-func-params@23 \
         /app/core/c-src/bindings.c \
         /root/meos-install/lib/libmeos.a \
         /root/geos/build/lib/libgeos.a \
@@ -276,7 +417,10 @@ RUN mkdir -p /app/wasm \
         /root/gsl-wasm/lib/libgslcblas.a \
         /root/json-c-install/lib/libjson-c.a \
         /root/h3-install/lib/libh3.a \
-        -I/root/meos-install/include \
+        /root/gdal-install/lib/libgdal.a \
+        /root/libxml2-install/lib/libxml2.a \
+        /root/zlib-install/lib/libz.a \
+        $(PKG_CONFIG_PATH=/root/meos-install/lib/pkgconfig pkg-config --cflags meos) \
         -I/root/geos/include \
         -I/root/geos/build/capi \
         -I/root/PROJ/src \
diff --git a/codegen/FunctionsGenerator.ts b/codegen/FunctionsGenerator.ts
index 6ffd924..622b9d5 100644
--- a/codegen/FunctionsGenerator.ts
+++ b/codegen/FunctionsGenerator.ts
@@ -41,6 +41,8 @@ interface Param {
 interface IdlFunction {
 	name: string;
 	file: string;
+	api: string;
+	family: string;
 	returnType: ReturnType;
 	params: Param[];
 }
@@ -842,62 +844,21 @@ function main(): void {
 	console.log('Reading IDL:', idlPath);
 	const idl: Idl = JSON.parse(fs.readFileSync(idlPath, 'utf-8'));
 
-	// The binding compiles C wrappers that CALL each MEOS function, so it can only
-	// use symbols that are DECLARED in a header the wrapper preamble #includes — the
-	// public meos_*.h umbrella headers (bindings_c_header.c.template). A function the
-	// catalog attributes to an internal fine-grained header (e.g. cbuffer.h,
-	// tcbuffer.h, temporal.h, meos_internal.h) is not declared there and often uses
-	// non-marshalable internal types (double2, Datum), so emitting a wrapper for it
-	// fails the emcc compile. The catalog attributes each public function to its
-	// umbrella and each internal-only function to the fine-grained header, so the
-	// public API is exactly the set of umbrella headers below — the same list the
-	// template #includes and the Dockerfile builds (CBUFFER/NPOINT/POSE/RGEO + H3 via
-	// libh3, JSON via json-c, QUADBIN via libm). The two families whose native
-	// libraries do not yet cross-compile to wasm — POINTCLOUD (pgpointcloud: libpc +
-	// lazperf) and RASTER (GDAL) — are excluded by leaving their umbrellas
-	// (meos_pointcloud.h, meos_raster.h) out. To add a family: add its umbrella here,
-	// #include it in the template, and flip its -D<FAMILY>=ON in the Dockerfile.
-	// Only top-level meos/include/*.h umbrellas belong here; meos_catalog.h lives in
-	// meos/include/temporal/ and is an internal type-system header (its accessors are
-	// `inline`, hence unlinkable from a separate TU), so it is deliberately excluded.
-	const API_HEADERS = new Set([
-		'meos.h',
-		'meos_error.h',
-		'meos_geo.h',
-		'meos_cbuffer.h',
-		'meos_npoint.h',
-		'meos_pose.h',
-		'meos_rgeo.h',
-		'meos_h3.h',
-		'meos_json.h',
-		'meos_quadbin.h',
-		// The PostgreSQL-compat base I/O (interval_in, interval_out, …). MEOS
-		// splices these declarations into the installed <meos.h> at build time
-		// (meos/CMakeLists.txt), so they are reachable through the umbrella this
-		// preamble already includes, even though the catalog attributes them to
-		// their own declaring header. Both spellings are listed because that
-		// attribution has moved: an older catalog says postgres_ext_defs.in.h,
-		// a current one says pg_interval.h.
-		'postgres_ext_defs.in.h',
-		'pg_interval.h',
-	]);
-	// A few disabled-family symbols are declared (under #if POINTCLOUD guards) inside
-	// otherwise-public umbrellas — meos.h and meos_catalog.h — so the umbrella
-	// allow-list alone does not exclude them. The guard compiles them out when the
-	// family is off, so a wrapper for them would reference an undeclared symbol.
-	// Exclude them by name; drop an entry here when its family is enabled.
-	const DISABLED_FAMILY_FUNCTIONS = new Set([
-		// POINTCLOUD (guarded in meos.h / meos_catalog.h)
-		'meos_initialize_pointcloud',
-		'rtree_create_tpcbox',
-		'pointcloud_basetype',
-		'pointcloudset_type',
-		'tpointcloud_temptype',
-	]);
-	const fns: IdlFunction[] = (idl.functions ?? []).filter(
-		f => API_HEADERS.has(f.file) && !DISABLED_FAMILY_FUNCTIONS.has(f.name)
-	);
-
+	// The emitted surface is every function the catalog calls public. `api` is
+	// derived from the @ingroup doxygen tag in MEOS's own sources, so the binding
+	// asks MEOS what it publishes rather than deciding from the header a symbol
+	// happens to be declared in.
+	//
+	// The preamble is the set of headers those functions come from, taken from the
+	// catalog too. A header list written here is a copy of that set kept by hand,
+	// and it goes stale in one direction only: a family MobilityDB adds is absent
+	// from the copy, so its whole surface is dropped with nothing reporting it.
+	// MEOS installs a family's umbrella only when the family is built, and the
+	// image builds them all, so every header named here is present.
+	const fns: IdlFunction[] = (idl.functions ?? []).filter(f => f.api === 'public');
+
+	const includes = [...new Set(fns.map(f => f.file))].sort()
+		.map(h => `#include <${h}>`).join('\n');
 	// The marker banner is emitted here rather than stored in the source templates
 	// (which are hand-edited). Its text is assembled from parts so this generator is
 	// not itself flagged by tooling that scans for the marker.
@@ -905,7 +866,7 @@ function main(): void {
 	let cOut = BANNER + fs.readFileSync(
 		path.resolve(__dirname, 'res/bindings_c_header.c.template'),
 		'utf-8'
-	);
+	).replace('/* @GENERATED_INCLUDES@ */', includes);
 	let tsOut = BANNER + fs.readFileSync(
 		path.resolve(__dirname, 'res/functions_ts_header.ts.template'),
 		'utf-8'
diff --git a/codegen/res/bindings_c_header.c.template b/codegen/res/bindings_c_header.c.template
index ecd4463..8660ee3 100644
--- a/codegen/res/bindings_c_header.c.template
+++ b/codegen/res/bindings_c_header.c.template
@@ -16,15 +16,7 @@
  * accessors are missing from it, and they are defined below beside the
  * Int64GetDatum/Float8GetDatum this file already supplies for the same reason.
  */
-#include <meos.h>
-#include <meos_geo.h>
-#include <meos_cbuffer.h>
-#include <meos_npoint.h>
-#include <meos_pose.h>
-#include <meos_rgeo.h>
-#include <meos_h3.h>
-#include <meos_json.h>
-#include <meos_quadbin.h>
+/* @GENERATED_INCLUDES@ */
 #include <emscripten.h>
 
 /*
diff --git a/core/c-src/bindings.c b/core/c-src/bindings.c
index c7cbbd9..a0f8da7 100644
--- a/core/c-src/bindings.c
+++ b/core/c-src/bindings.c
@@ -18,14 +18,26 @@
  * Int64GetDatum/Float8GetDatum this file already supplies for the same reason.
  */
 #include <meos.h>
-#include <meos_geo.h>
 #include <meos_cbuffer.h>
-#include <meos_npoint.h>
-#include <meos_pose.h>
-#include <meos_rgeo.h>
+#include <meos_cellindex.h>
+#include <meos_geo.h>
 #include <meos_h3.h>
 #include <meos_json.h>
+#include <meos_npoint.h>
+#include <meos_pointcloud.h>
+#include <meos_pose.h>
 #include <meos_quadbin.h>
+#include <meos_raster.h>
+#include <meos_rgeo.h>
+#include <meos_s2cell.h>
+#include <pg_bool.h>
+#include <pg_date.h>
+#include <pg_float.h>
+#include <pg_int.h>
+#include <pg_interval.h>
+#include <pg_text.h>
+#include <pg_time.h>
+#include <pg_timestamp.h>
 #include <emscripten.h>
 
 /*
@@ -440,13 +452,6 @@ int text_cmp_w(const char * txt1, const char * txt2, Oid collid) {
   return text_cmp(cstring_to_text(txt1), cstring_to_text(txt2), collid);
 }
 
-EMSCRIPTEN_KEEPALIVE
-char * text_copy_w(const char * txt) {
-  text *_t = text_copy(cstring_to_text(txt));
-  if (!_t) return NULL;
-  return text_to_cstring(_t);
-}
-
 EMSCRIPTEN_KEEPALIVE
 char * text_initcap_w(const char * txt) {
   text *_t = text_initcap(cstring_to_text(txt));
@@ -570,6 +575,11 @@ RTree * rtree_create_stbox_w() {
   return rtree_create_stbox();
 }
 
+EMSCRIPTEN_KEEPALIVE
+RTree * rtree_create_tpcbox_w() {
+  return rtree_create_tpcbox();
+}
+
 EMSCRIPTEN_KEEPALIVE
 void rtree_free_w(RTree * rtree) {
   rtree_free(rtree);
@@ -625,11 +635,6 @@ int rtree_search_temporal_w(const RTree * rtree, IndexSearchOp op, const Tempora
   return rtree_search_temporal(rtree, op, temp, result);
 }
 
-EMSCRIPTEN_KEEPALIVE
-int rtree_search_temporal_dedup_w(const RTree * rtree, IndexSearchOp op, const Temporal * temp, int maxboxes, MeosArray * result) {
-  return rtree_search_temporal_dedup(rtree, op, temp, maxboxes, result);
-}
-
 EMSCRIPTEN_KEEPALIVE
 RTreeNNCursor * rtree_nn_cursor_open_w(const RTree * rtree, const void * query) {
   return rtree_nn_cursor_open(rtree, query);
@@ -740,11 +745,6 @@ int sptree_search_temporal_w(const SPTree * sptree, IndexSearchOp op, const Temp
   return sptree_search_temporal(sptree, op, temp, result);
 }
 
-EMSCRIPTEN_KEEPALIVE
-int sptree_search_temporal_dedup_w(const SPTree * sptree, IndexSearchOp op, const Temporal * temp, int maxboxes, MeosArray * result) {
-  return sptree_search_temporal_dedup(sptree, op, temp, maxboxes, result);
-}
-
 EMSCRIPTEN_KEEPALIVE
 SPNNCursor * sptree_nn_cursor_open_w(const SPTree * sptree, const void * query) {
   return sptree_nn_cursor_open(sptree, query);
@@ -780,6 +780,11 @@ void meos_finalize_collation_w() {
   meos_finalize_collation();
 }
 
+EMSCRIPTEN_KEEPALIVE
+void meos_initialize_pointcloud_w() {
+  meos_initialize_pointcloud();
+}
+
 EMSCRIPTEN_KEEPALIVE
 int meos_set_datestyle_w(const char * newval, void * extra) {
   return (int) meos_set_datestyle(newval, extra);
@@ -4877,11 +4882,6 @@ int64_t * tbigint_values_w(const Temporal * temp, int32 * count) {
   return tbigint_values(temp, count);
 }
 
-EMSCRIPTEN_KEEPALIVE
-double tnumber_avg_value_w(const Temporal * temp) {
-  return tnumber_avg_value(temp);
-}
-
 EMSCRIPTEN_KEEPALIVE
 double tnumber_integral_w(const Temporal * temp) {
   return tnumber_integral(temp);
@@ -6320,6 +6320,11 @@ int overlaps_temporal_temporal_w(const Temporal * temp1, const Temporal * temp2)
   return (int) overlaps_temporal_temporal(temp1, temp2);
 }
 
+EMSCRIPTEN_KEEPALIVE
+int temporal_time_overlaps_w(const Temporal * temp1, const Temporal * temp2) {
+  return (int) temporal_time_overlaps(temp1, temp2);
+}
+
 EMSCRIPTEN_KEEPALIVE
 int overlaps_temporal_tstzspan_w(const Temporal * temp, const Span * s) {
   return (int) overlaps_temporal_tstzspan(temp, s);
@@ -9197,11 +9202,6 @@ int acontains_tgeo_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
   return acontains_tgeo_geo(temp, gs);
 }
 
-EMSCRIPTEN_KEEPALIVE
-int acontains_tgeo_tgeo_w(const Temporal * temp1, const Temporal * temp2) {
-  return acontains_tgeo_tgeo(temp1, temp2);
-}
-
 EMSCRIPTEN_KEEPALIVE
 int acovers_geo_tgeo_w(const GSERIALIZED * gs, const Temporal * temp) {
   return acovers_geo_tgeo(gs, temp);
@@ -10389,11 +10389,6 @@ int atouches_tcbuffer_cbuffer_w(const Temporal * temp, const Cbuffer * cb) {
   return atouches_tcbuffer_cbuffer(temp, cb);
 }
 
-EMSCRIPTEN_KEEPALIVE
-int atouches_tcbuffer_tcbuffer_w(const Temporal * temp1, const Temporal * temp2) {
-  return atouches_tcbuffer_tcbuffer(temp1, temp2);
-}
-
 EMSCRIPTEN_KEEPALIVE
 int econtains_cbuffer_tcbuffer_w(const Cbuffer * cb, const Temporal * temp) {
   return econtains_cbuffer_tcbuffer(cb, temp);
@@ -10640,6 +10635,39 @@ Temporal * ttouches_tcbuffer_tcbuffer_w(const Temporal * temp1, const Temporal *
 }
 
 
+/* === meos_cellindex.h === */
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tcellindex_get_resolution_w(const Temporal * temp) {
+  return tcellindex_get_resolution(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tcellindex_is_valid_cell_w(const Temporal * temp) {
+  return tcellindex_is_valid_cell(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tcellindex_cell_to_parent_w(const Temporal * temp, int32 resolution) {
+  return tcellindex_cell_to_parent(temp, resolution);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tcellindex_cell_to_point_w(const Temporal * temp) {
+  return tcellindex_cell_to_point(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tcellindex_cell_to_boundary_w(const Temporal * temp) {
+  return tcellindex_cell_to_boundary(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tcellindex_cell_area_w(const Temporal * temp) {
+  return tcellindex_cell_area(temp);
+}
+
+
 /* === meos_h3.h === */
 
 EMSCRIPTEN_KEEPALIVE
@@ -11768,21 +11796,6 @@ char * tjsonb_out_w(const Temporal * temp) {
   return tjsonb_out(temp);
 }
 
-EMSCRIPTEN_KEEPALIVE
-TInstant * tjsonbinst_in_w(const char * str) {
-  return tjsonbinst_in(str);
-}
-
-EMSCRIPTEN_KEEPALIVE
-TSequence * tjsonbseq_in_w(const char * str, interpType interp) {
-  return tjsonbseq_in(str, interp);
-}
-
-EMSCRIPTEN_KEEPALIVE
-TSequenceSet * tjsonbseqset_in_w(const char * str) {
-  return tjsonbseqset_in(str);
-}
-
 EMSCRIPTEN_KEEPALIVE
 Temporal * tjsonb_from_base_temp_w(const Jsonb * jsonb, const Temporal * temp) {
   return tjsonb_from_base_temp(jsonb, temp);
@@ -12753,1062 +12766,2783 @@ Temporal * tne_tnpoint_npoint_w(const Temporal * temp, const Npoint * np) {
 }
 
 
-/* === meos_pose.h === */
+/* === meos_pointcloud.h === */
 
 EMSCRIPTEN_KEEPALIVE
-char * pose_as_ewkt_w(const Pose * pose, int maxdd) {
-  return pose_as_ewkt(pose, maxdd);
+Pcpoint * pcpoint_hex_in_w(const char * str) {
+  return pcpoint_hex_in(str);
 }
 
 EMSCRIPTEN_KEEPALIVE
-char * pose_as_hexwkb_w(const Pose * pose, uint8_t variant, size_t * size_out) {
-  return pose_as_hexwkb(pose, variant, size_out);
+char * pcpoint_hex_out_w(const Pcpoint * pt, int maxdd) {
+  return pcpoint_hex_out(pt, maxdd);
 }
 
 EMSCRIPTEN_KEEPALIVE
-char * pose_as_text_w(const Pose * pose, int maxdd) {
-  return pose_as_text(pose, maxdd);
+Pcpoint * pcpoint_from_hexwkb_w(const char * hexwkb) {
+  return pcpoint_from_hexwkb(hexwkb);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint8_t * pose_as_wkb_w(const Pose * pose, uint8_t variant, size_t * size_out) {
-  return pose_as_wkb(pose, variant, size_out);
+char * pcpoint_as_hexwkb_w(const Pcpoint * pt) {
+  return pcpoint_as_hexwkb(pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_from_wkb_w(const uint8_t * wkb, size_t size) {
-  return pose_from_wkb(wkb, size);
+Pcpoint * pcpoint_make_w(uint32_t pcid, const double * values, int count) {
+  return pcpoint_make(pcid, values, count);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_from_hexwkb_w(const char * hexwkb) {
-  return pose_from_hexwkb(hexwkb);
+Pcpoint * pcpoint_copy_w(const Pcpoint * pt) {
+  return pcpoint_copy(pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_in_w(const char * str) {
-  return pose_in(str);
+uint32_t pcpoint_get_pcid_w(const Pcpoint * pt) {
+  return pcpoint_get_pcid(pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-char * pose_out_w(const Pose * pose, int maxdd) {
-  return pose_out(pose, maxdd);
+uint32_t pcpoint_hash_w(const Pcpoint * pt) {
+  return pcpoint_hash(pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_from_geopose_w(const char * json) {
-  return pose_from_geopose(json);
+uint64_t pcpoint_hash_extended_w(const Pcpoint * pt, uint64_t seed) {
+  return pcpoint_hash_extended(pt, seed);
 }
 
 EMSCRIPTEN_KEEPALIVE
-char * pose_as_geopose_w(const Pose * pose, int conformance, int precision) {
-  return pose_as_geopose(pose, conformance, precision);
+int pcpoint_get_x_w(const Pcpoint * pt, PCSCHEMA * schema, double * out) {
+  return (int) pcpoint_get_x(pt, schema, out);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_from_geopose_w(const char * json) {
-  return tpose_from_geopose(json);
+int pcpoint_get_y_w(const Pcpoint * pt, PCSCHEMA * schema, double * out) {
+  return (int) pcpoint_get_y(pt, schema, out);
 }
 
 EMSCRIPTEN_KEEPALIVE
-char * tpose_as_geopose_w(const Temporal * temp, int conformance, int precision) {
-  return tpose_as_geopose(temp, conformance, precision);
+int pcpoint_get_z_w(const Pcpoint * pt, PCSCHEMA * schema, double * out) {
+  return (int) pcpoint_get_z(pt, schema, out);
 }
 
 EMSCRIPTEN_KEEPALIVE
-char * tpose_as_geopose_stream_header_w(const Temporal * temp, int precision) {
-  return tpose_as_geopose_stream_header(temp, precision);
+int pcpoint_get_dim_w(const Pcpoint * pt, PCSCHEMA * schema, const char * name, double * out) {
+  return (int) pcpoint_get_dim(pt, schema, name, out);
 }
 
 EMSCRIPTEN_KEEPALIVE
-char * tpose_as_geopose_stream_element_w(const Temporal * temp, const TInstant * inst, int precision) {
-  return tpose_as_geopose_stream_element(temp, inst, precision);
+TPCBox * pcpoint_to_tpcbox_w(const Pcpoint * pt, PCSCHEMA * schema) {
+  return pcpoint_to_tpcbox(pt, schema);
 }
 
 EMSCRIPTEN_KEEPALIVE
-char * tpose_as_geopose_stream_w(const Temporal * temp, int precision) {
-  return tpose_as_geopose_stream(temp, precision);
+PCSCHEMA * meos_pc_schema_w(uint32_t pcid) {
+  return meos_pc_schema(pcid);
 }
 
 EMSCRIPTEN_KEEPALIVE
-const GeoPoseFrame * geopose_frames_w(int * count) {
-  return geopose_frames(count);
+void meos_pc_schema_register_w(uint32_t pcid, PCSCHEMA * schema) {
+  meos_pc_schema_register(pcid, schema);
 }
 
 EMSCRIPTEN_KEEPALIVE
-const GeoPoseFrame * geopose_frame_w(int32_t frame_id) {
-  return geopose_frame(frame_id);
+PCSCHEMA * meos_pc_schema_from_dims_w(uint32_t pcid, int32_t srid, const char * compression, const PCDimensionSpec * dims, int ndims) {
+  return meos_pc_schema_from_dims(pcid, srid, compression, dims, ndims);
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * pose_apply_geo_w(const Pose * pose, const GSERIALIZED * body) {
-  return pose_apply_geo(pose, body);
+int meos_pc_schema_register_dims_w(uint32_t pcid, int32_t srid, const char * compression, const PCDimensionSpec * dims, int ndims) {
+  return (int) meos_pc_schema_register_dims(pcid, srid, compression, dims, ndims);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_apply_geo_w(const Temporal * temp, const GSERIALIZED * body) {
-  return tpose_apply_geo(temp, body);
+void meos_pc_schema_register_xml_w(uint32_t pcid, PCSCHEMA * schema, const char * xml_text) {
+  meos_pc_schema_register_xml(pcid, schema, xml_text);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_compose_pose_w(const Temporal * body, const Pose * frame) {
-  return tpose_compose_pose(body, frame);
+const char * meos_pc_schema_xml_w(uint32_t pcid) {
+  return meos_pc_schema_xml(pcid);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * pose_compose_tpose_w(const Pose * body, const Temporal * frame) {
-  return pose_compose_tpose(body, frame);
+void meos_pc_schema_clear_w() {
+  meos_pc_schema_clear();
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_compose_tpose_w(const Temporal * body, const Temporal * frame) {
-  return tpose_compose_tpose(body, frame);
+int32_t meos_pc_schema_srid_w(uint32_t pcid) {
+  return meos_pc_schema_srid(pcid);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_inverse_w(const Temporal * temp) {
-  return tpose_inverse(temp);
+const char * meos_pc_schema_compression_w(uint32_t pcid) {
+  return meos_pc_schema_compression(pcid);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_copy_w(const Pose * pose) {
-  return pose_copy(pose);
+int32_t meos_pc_schema_ndims_w(uint32_t pcid) {
+  return meos_pc_schema_ndims(pcid);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_make_2d_w(double x, double y, double theta, int geodetic, int32_t srid) {
-  return pose_make_2d(x, y, theta, (bool) geodetic, srid);
+void meos_set_pointcloud_schemas_xml_w(const char * path) {
+  meos_set_pointcloud_schemas_xml(path);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_make_3d_w(double x, double y, double z, double W, double X, double Y, double Z, int geodetic, int32_t srid) {
-  return pose_make_3d(x, y, z, W, X, Y, Z, (bool) geodetic, srid);
+int pcpoint_cmp_w(const Pcpoint * pt1, const Pcpoint * pt2) {
+  return pcpoint_cmp(pt1, pt2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_make_point2d_w(const GSERIALIZED * gs, double theta) {
-  return pose_make_point2d(gs, theta);
+int pcpoint_eq_w(const Pcpoint * pt1, const Pcpoint * pt2) {
+  return (int) pcpoint_eq(pt1, pt2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_make_point3d_w(const GSERIALIZED * gs, double W, double X, double Y, double Z) {
-  return pose_make_point3d(gs, W, X, Y, Z);
+int pcpoint_ne_w(const Pcpoint * pt1, const Pcpoint * pt2) {
+  return (int) pcpoint_ne(pt1, pt2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_make_point3d_ypr_w(const GSERIALIZED * gs, double yaw, double pitch, double roll) {
-  return pose_make_point3d_ypr(gs, yaw, pitch, roll);
+int pcpoint_lt_w(const Pcpoint * pt1, const Pcpoint * pt2) {
+  return (int) pcpoint_lt(pt1, pt2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * pose_to_point_w(const Pose * pose) {
-  return pose_to_point(pose);
+int pcpoint_le_w(const Pcpoint * pt1, const Pcpoint * pt2) {
+  return (int) pcpoint_le(pt1, pt2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-STBox * pose_to_stbox_w(const Pose * pose) {
-  return pose_to_stbox(pose);
+int pcpoint_gt_w(const Pcpoint * pt1, const Pcpoint * pt2) {
+  return (int) pcpoint_gt(pt1, pt2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint32_t pose_hash_w(const Pose * pose) {
-  return pose_hash(pose);
+int pcpoint_ge_w(const Pcpoint * pt1, const Pcpoint * pt2) {
+  return (int) pcpoint_ge(pt1, pt2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint64_t pose_hash_extended_w(const Pose * pose, uint64_t seed) {
-  return pose_hash_extended(pose, seed);
+Pcpatch * pcpatch_hex_in_w(const char * str) {
+  return pcpatch_hex_in(str);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double * pose_quaternion_w(const Pose * pose, int * count) {
-  return pose_quaternion(pose, count);
+char * pcpatch_hex_out_w(const Pcpatch * pa, int maxdd) {
+  return pcpatch_hex_out(pa, maxdd);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double * pose_ypr_w(const Pose * pose, int * count) {
-  return pose_ypr(pose, count);
+Pcpatch * pcpatch_from_hexwkb_w(const char * hexwkb) {
+  return pcpatch_from_hexwkb(hexwkb);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double pose_yaw_w(const Pose * pose) {
-  return pose_yaw(pose);
+char * pcpatch_as_hexwkb_w(const Pcpatch * pa) {
+  return pcpatch_as_hexwkb(pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double pose_pitch_w(const Pose * pose) {
-  return pose_pitch(pose);
+Pcpatch * pcpatch_make_w(const Pcpoint ** points, int count) {
+  return pcpatch_make(points, count);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double pose_roll_w(const Pose * pose) {
-  return pose_roll(pose);
+Pcpatch * pcpatch_make_coords_w(uint32_t pcid, const double * values, int count) {
+  return pcpatch_make_coords(pcid, values, count);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double pose_angular_distance_w(const Pose * pose1, const Pose * pose2) {
-  return pose_angular_distance(pose1, pose2);
+Pcpatch * pcpatch_copy_w(const Pcpatch * pa) {
+  return pcpatch_copy(pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_compose_w(const Pose * body, const Pose * frame) {
-  return pose_compose(body, frame);
+uint32_t pcpatch_get_pcid_w(const Pcpatch * pa) {
+  return pcpatch_get_pcid(pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_inverse_w(const Pose * pose) {
-  return pose_inverse(pose);
+uint32_t pcpatch_npoints_w(const Pcpatch * pa) {
+  return pcpatch_npoints(pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_normalize_w(const Pose * pose) {
-  return pose_normalize(pose);
+uint32_t pcpatch_hash_w(const Pcpatch * pa) {
+  return pcpatch_hash(pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_round_w(const Pose * pose, int maxdd) {
-  return pose_round(pose, maxdd);
+uint64_t pcpatch_hash_extended_w(const Pcpatch * pa, uint64_t seed) {
+  return pcpatch_hash_extended(pa, seed);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose ** posearr_round_w(const Pose ** posearr, int count, int maxdd) {
-  return posearr_round(posearr, count, maxdd);
+GSERIALIZED * pcpatch_to_geom_w(const Pcpatch * pa) {
+  return pcpatch_to_geom(pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_set_srid_w(const Pose * pose, int32_t srid) {
-  return pose_set_srid(pose, srid);
+int pcpatch_cmp_w(const Pcpatch * pa1, const Pcpatch * pa2) {
+  return pcpatch_cmp(pa1, pa2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int32_t pose_srid_w(const Pose * pose) {
-  return pose_srid(pose);
+int pcpatch_eq_w(const Pcpatch * pa1, const Pcpatch * pa2) {
+  return (int) pcpatch_eq(pa1, pa2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_transform_w(const Pose * pose, int32_t srid) {
-  return pose_transform(pose, srid);
+int pcpatch_ne_w(const Pcpatch * pa1, const Pcpatch * pa2) {
+  return (int) pcpatch_ne(pa1, pa2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * pose_transform_pipeline_w(const Pose * pose, const char * pipelinestr, int32_t srid, int is_forward) {
-  return pose_transform_pipeline(pose, pipelinestr, srid, (bool) is_forward);
+int pcpatch_lt_w(const Pcpatch * pa1, const Pcpatch * pa2) {
+  return (int) pcpatch_lt(pa1, pa2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-STBox * pose_tstzspan_to_stbox_w(const Pose * pose, const Span * s) {
-  return pose_tstzspan_to_stbox(pose, s);
+int pcpatch_le_w(const Pcpatch * pa1, const Pcpatch * pa2) {
+  return (int) pcpatch_le(pa1, pa2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-STBox * pose_timestamptz_to_stbox_w(const Pose * pose, long long t) {
-  return pose_timestamptz_to_stbox(pose, (TimestampTz) t);
+int pcpatch_gt_w(const Pcpatch * pa1, const Pcpatch * pa2) {
+  return (int) pcpatch_gt(pa1, pa2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double distance_pose_geo_w(const Pose * pose, const GSERIALIZED * gs) {
-  return distance_pose_geo(pose, gs);
+int pcpatch_ge_w(const Pcpatch * pa1, const Pcpatch * pa2) {
+  return (int) pcpatch_ge(pa1, pa2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double distance_pose_pose_w(const Pose * pose1, const Pose * pose2) {
-  return distance_pose_pose(pose1, pose2);
+Set * pcpointset_in_w(const char * str) {
+  return pcpointset_in(str);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double distance_pose_stbox_w(const Pose * pose, const STBox * box) {
-  return distance_pose_stbox(pose, box);
+char * pcpointset_out_w(const Set * s, int maxdd) {
+  return pcpointset_out(s, maxdd);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int pose_cmp_w(const Pose * pose1, const Pose * pose2) {
-  return pose_cmp(pose1, pose2);
+Set * pcpointset_make_w(Pcpoint ** values, int count) {
+  return pcpointset_make(values, count);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int pose_eq_w(const Pose * pose1, const Pose * pose2) {
-  return (int) pose_eq(pose1, pose2);
+Set * pcpoint_to_set_w(const Pcpoint * pt) {
+  return pcpoint_to_set(pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int pose_ge_w(const Pose * pose1, const Pose * pose2) {
-  return (int) pose_ge(pose1, pose2);
+Pcpoint * pcpointset_start_value_w(const Set * s) {
+  return pcpointset_start_value(s);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int pose_gt_w(const Pose * pose1, const Pose * pose2) {
-  return (int) pose_gt(pose1, pose2);
+Pcpoint * pcpointset_end_value_w(const Set * s) {
+  return pcpointset_end_value(s);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int pose_le_w(const Pose * pose1, const Pose * pose2) {
-  return (int) pose_le(pose1, pose2);
+Pcpoint * pcpointset_value_n_w(const Set * s, int n) {
+  Pcpoint * r;
+  if (!pcpointset_value_n(s, n, &r)) return NULL;
+  return r;
 }
 
 EMSCRIPTEN_KEEPALIVE
-int pose_lt_w(const Pose * pose1, const Pose * pose2) {
-  return (int) pose_lt(pose1, pose2);
+Pcpoint ** pcpointset_values_w(const Set * s, int * count) {
+  return pcpointset_values(s, count);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int pose_ne_w(const Pose * pose1, const Pose * pose2) {
-  return (int) pose_ne(pose1, pose2);
+int contains_set_pcpoint_w(const Set * s, Pcpoint * pt) {
+  return (int) contains_set_pcpoint(s, pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int pose_nsame_w(const Pose * pose1, const Pose * pose2) {
-  return (int) pose_nsame(pose1, pose2);
+int contained_pcpoint_set_w(const Pcpoint * pt, const Set * s) {
+  return (int) contained_pcpoint_set(pt, s);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int pose_same_w(const Pose * pose1, const Pose * pose2) {
-  return (int) pose_same(pose1, pose2);
+Set * intersection_pcpoint_set_w(const Pcpoint * pt, const Set * s) {
+  return intersection_pcpoint_set(pt, s);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Set * poseset_in_w(const char * str) {
-  return poseset_in(str);
+Set * intersection_set_pcpoint_w(const Set * s, const Pcpoint * pt) {
+  return intersection_set_pcpoint(s, pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-char * poseset_out_w(const Set * s, int maxdd) {
-  return poseset_out(s, maxdd);
+Set * minus_pcpoint_set_w(const Pcpoint * pt, const Set * s) {
+  return minus_pcpoint_set(pt, s);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Set * poseset_make_w(const Pose ** values, int count) {
-  return poseset_make(values, count);
+Set * minus_set_pcpoint_w(const Set * s, const Pcpoint * pt) {
+  return minus_set_pcpoint(s, pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Set * pose_to_set_w(const Pose * pose) {
-  return pose_to_set(pose);
+Set * union_pcpoint_set_w(const Pcpoint * pt, const Set * s) {
+  return union_pcpoint_set(pt, s);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * poseset_end_value_w(const Set * s) {
-  return poseset_end_value(s);
+Set * union_set_pcpoint_w(const Set * s, const Pcpoint * pt) {
+  return union_set_pcpoint(s, pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * poseset_start_value_w(const Set * s) {
-  return poseset_start_value(s);
+Set * pcpoint_union_transfn_w(Set * state, const Pcpoint * pt) {
+  return pcpoint_union_transfn(state, pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * poseset_value_n_w(const Set * s, int n) {
-  Pose * r;
-  if (!poseset_value_n(s, n, &r)) return NULL;
-  return r;
+Set * pcpatchset_in_w(const char * str) {
+  return pcpatchset_in(str);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose ** poseset_values_w(const Set * s, int * count) {
-  return poseset_values(s, count);
+char * pcpatchset_out_w(const Set * s, int maxdd) {
+  return pcpatchset_out(s, maxdd);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int contained_pose_set_w(const Pose * pose, const Set * s) {
-  return (int) contained_pose_set(pose, s);
+Set * pcpatchset_make_w(Pcpatch ** values, int count) {
+  return pcpatchset_make(values, count);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int contains_set_pose_w(const Set * s, Pose * pose) {
-  return (int) contains_set_pose(s, pose);
+Set * pcpatch_to_set_w(const Pcpatch * pa) {
+  return pcpatch_to_set(pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Set * intersection_pose_set_w(const Pose * pose, const Set * s) {
-  return intersection_pose_set(pose, s);
+Pcpatch * pcpatchset_start_value_w(const Set * s) {
+  return pcpatchset_start_value(s);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Set * intersection_set_pose_w(const Set * s, const Pose * pose) {
-  return intersection_set_pose(s, pose);
+Pcpatch * pcpatchset_end_value_w(const Set * s) {
+  return pcpatchset_end_value(s);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Set * minus_pose_set_w(const Pose * pose, const Set * s) {
-  return minus_pose_set(pose, s);
+Pcpatch * pcpatchset_value_n_w(const Set * s, int n) {
+  Pcpatch * r;
+  if (!pcpatchset_value_n(s, n, &r)) return NULL;
+  return r;
 }
 
 EMSCRIPTEN_KEEPALIVE
-Set * minus_set_pose_w(const Set * s, const Pose * pose) {
-  return minus_set_pose(s, pose);
+Pcpatch ** pcpatchset_values_w(const Set * s, int * count) {
+  return pcpatchset_values(s, count);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Set * pose_union_transfn_w(Set * state, const Pose * pose) {
-  return pose_union_transfn(state, pose);
+int contains_set_pcpatch_w(const Set * s, Pcpatch * pa) {
+  return (int) contains_set_pcpatch(s, pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Set * union_pose_set_w(const Pose * pose, const Set * s) {
-  return union_pose_set(pose, s);
+int contained_pcpatch_set_w(const Pcpatch * pa, const Set * s) {
+  return (int) contained_pcpatch_set(pa, s);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Set * union_set_pose_w(const Set * s, const Pose * pose) {
-  return union_set_pose(s, pose);
+Set * intersection_pcpatch_set_w(const Pcpatch * pa, const Set * s) {
+  return intersection_pcpatch_set(pa, s);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_from_mfjson_w(const char * str) {
-  return tpose_from_mfjson(str);
+Set * intersection_set_pcpatch_w(const Set * s, const Pcpatch * pa) {
+  return intersection_set_pcpatch(s, pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_in_w(const char * str) {
-  return tpose_in(str);
+Set * minus_pcpatch_set_w(const Pcpatch * pa, const Set * s) {
+  return minus_pcpatch_set(pa, s);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TInstant * tposeinst_make_w(const Pose * pose, long long t) {
-  return tposeinst_make(pose, (TimestampTz) t);
+Set * minus_set_pcpatch_w(const Set * s, const Pcpatch * pa) {
+  return minus_set_pcpatch(s, pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_from_base_temp_w(const Pose * pose, const Temporal * temp) {
-  return tpose_from_base_temp(pose, temp);
+Set * union_pcpatch_set_w(const Pcpatch * pa, const Set * s) {
+  return union_pcpatch_set(pa, s);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequence * tposeseq_from_base_tstzset_w(const Pose * pose, const Set * s) {
-  return tposeseq_from_base_tstzset(pose, s);
+Set * union_set_pcpatch_w(const Set * s, const Pcpatch * pa) {
+  return union_set_pcpatch(s, pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequence * tposeseq_from_base_tstzspan_w(const Pose * pose, const Span * s, interpType interp) {
-  return tposeseq_from_base_tstzspan(pose, s, interp);
+Set * pcpatch_union_transfn_w(Set * state, const Pcpatch * pa) {
+  return pcpatch_union_transfn(state, pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequenceSet * tposeseqset_from_base_tstzspanset_w(const Pose * pose, const SpanSet * ss, interpType interp) {
-  return tposeseqset_from_base_tstzspanset(pose, ss, interp);
+TPCBox * tpcbox_in_w(const char * str) {
+  return tpcbox_in(str);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_make_w(const Temporal * tpoint, const Temporal * ttheta) {
-  return tpose_make(tpoint, ttheta);
+char * tpcbox_out_w(const TPCBox * box, int maxdd) {
+  return tpcbox_out(box, maxdd);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_to_tpoint_w(const Temporal * temp) {
-  return tpose_to_tpoint(temp);
+TPCBox * tpcbox_make_w(int hasx, int hasz, int hast, int geodetic, int32_t srid, uint32_t pcid, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, const Span * period) {
+  return tpcbox_make((bool) hasx, (bool) hasz, (bool) hast, (bool) geodetic, srid, pcid, xmin, xmax, ymin, ymax, zmin, zmax, period);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * tpose_end_value_w(const Temporal * temp) {
-  return tpose_end_value(temp);
+TPCBox * tpcbox_copy_w(const TPCBox * box) {
+  return tpcbox_copy(box);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Set * tpose_points_w(const Temporal * temp) {
-  return tpose_points(temp);
+TPCBox * pcpatch_to_tpcbox_w(const Pcpatch * pa, int32_t srid) {
+  return pcpatch_to_tpcbox(pa, srid);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_yaw_w(const Temporal * temp) {
-  return tpose_yaw(temp);
+int tpcbox_hasx_w(const TPCBox * box) {
+  return (int) tpcbox_hasx(box);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_pitch_w(const Temporal * temp) {
-  return tpose_pitch(temp);
+int tpcbox_hasz_w(const TPCBox * box) {
+  return (int) tpcbox_hasz(box);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_roll_w(const Temporal * temp) {
-  return tpose_roll(temp);
+int tpcbox_hast_w(const TPCBox * box) {
+  return (int) tpcbox_hast(box);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_speed_w(const Temporal * temp) {
-  return tpose_speed(temp);
+int tpcbox_geodetic_w(const TPCBox * box) {
+  return (int) tpcbox_geodetic(box);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_angular_speed_w(const Temporal * temp) {
-  return tpose_angular_speed(temp);
+double tpcbox_xmin_w(const TPCBox * box) {
+  double r;
+  if (!tpcbox_xmin(box, &r)) return 0.0;
+  return r;
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * tpose_start_value_w(const Temporal * temp) {
-  return tpose_start_value(temp);
+double tpcbox_xmax_w(const TPCBox * box) {
+  double r;
+  if (!tpcbox_xmax(box, &r)) return 0.0;
+  return r;
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * tpose_trajectory_w(const Temporal * temp) {
-  return tpose_trajectory(temp);
+double tpcbox_ymin_w(const TPCBox * box) {
+  double r;
+  if (!tpcbox_ymin(box, &r)) return 0.0;
+  return r;
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * tpose_value_at_timestamptz_w(const Temporal * temp, long long t, int strict) {
-  Pose * r;
-  if (!tpose_value_at_timestamptz(temp, (TimestampTz) t, (bool) strict, &r)) return NULL;
+double tpcbox_ymax_w(const TPCBox * box) {
+  double r;
+  if (!tpcbox_ymax(box, &r)) return 0.0;
   return r;
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose * tpose_value_n_w(const Temporal * temp, int n) {
-  Pose * r;
-  if (!tpose_value_n(temp, n, &r)) return NULL;
+double tpcbox_zmin_w(const TPCBox * box) {
+  double r;
+  if (!tpcbox_zmin(box, &r)) return 0.0;
   return r;
 }
 
 EMSCRIPTEN_KEEPALIVE
-Pose ** tpose_values_w(const Temporal * temp, int * count) {
-  return tpose_values(temp, count);
+double tpcbox_zmax_w(const TPCBox * box) {
+  double r;
+  if (!tpcbox_zmax(box, &r)) return 0.0;
+  return r;
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_at_elevation_w(const Temporal * temp, const Span * s) {
-  return tpose_at_elevation(temp, s);
+long long tpcbox_tmin_w(const TPCBox * box) {
+  TimestampTz r;
+  if (!tpcbox_tmin(box, &r)) return 0;
+  return (long long) r;
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_at_geom_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return tpose_at_geom(temp, gs);
+int tpcbox_tmin_inc_w(const TPCBox * box) {
+  bool r;
+  if (!tpcbox_tmin_inc(box, &r)) return 0;
+  return (int) r;
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_at_stbox_w(const Temporal * temp, const STBox * box, int border_inc) {
-  return tpose_at_stbox(temp, box, (bool) border_inc);
+long long tpcbox_tmax_w(const TPCBox * box) {
+  TimestampTz r;
+  if (!tpcbox_tmax(box, &r)) return 0;
+  return (long long) r;
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_at_pose_w(const Temporal * temp, const Pose * pose) {
-  return tpose_at_pose(temp, pose);
+int tpcbox_tmax_inc_w(const TPCBox * box) {
+  bool r;
+  if (!tpcbox_tmax_inc(box, &r)) return 0;
+  return (int) r;
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_minus_elevation_w(const Temporal * temp, const Span * s) {
-  return tpose_minus_elevation(temp, s);
+int32_t tpcbox_srid_w(const TPCBox * box) {
+  return tpcbox_srid(box);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_minus_geom_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return tpose_minus_geom(temp, gs);
+uint32_t tpcbox_pcid_w(const TPCBox * box) {
+  return tpcbox_pcid(box);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_minus_pose_w(const Temporal * temp, const Pose * pose) {
-  return tpose_minus_pose(temp, pose);
+STBox * tpcbox_to_stbox_w(const TPCBox * box) {
+  return tpcbox_to_stbox(box);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tpose_minus_stbox_w(const Temporal * temp, const STBox * box, int border_inc) {
-  return tpose_minus_stbox(temp, box, (bool) border_inc);
+TPCBox * tpcbox_round_w(const TPCBox * box, int maxdd) {
+  return tpcbox_round(box, maxdd);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tdistance_tpose_pose_w(const Temporal * temp, const Pose * pose) {
-  return tdistance_tpose_pose(temp, pose);
+TPCBox * tpcbox_set_srid_w(const TPCBox * box, int32_t srid) {
+  return tpcbox_set_srid(box, srid);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tdistance_tpose_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return tdistance_tpose_geo(temp, gs);
+TPCBox * union_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2, int strict) {
+  return union_tpcbox_tpcbox(box1, box2, (bool) strict);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tdistance_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) {
-  return tdistance_tpose_tpose(temp1, temp2);
+TPCBox * intersection_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return intersection_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double nad_tpose_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return nad_tpose_geo(temp, gs);
+int contains_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) contains_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double nad_tpose_pose_w(const Temporal * temp, const Pose * pose) {
-  return nad_tpose_pose(temp, pose);
+int contained_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) contained_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double nad_tpose_stbox_w(const Temporal * temp, const STBox * box) {
-  return nad_tpose_stbox(temp, box);
+int overlaps_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) overlaps_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double nad_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) {
-  return nad_tpose_tpose(temp1, temp2);
+int same_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) same_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TInstant * nai_tpose_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return nai_tpose_geo(temp, gs);
+int adjacent_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) adjacent_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TInstant * nai_tpose_pose_w(const Temporal * temp, const Pose * pose) {
-  return nai_tpose_pose(temp, pose);
+int tpcbox_cmp_w(const TPCBox * box1, const TPCBox * box2) {
+  return tpcbox_cmp(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TInstant * nai_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) {
-  return nai_tpose_tpose(temp1, temp2);
+int tpcbox_eq_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) tpcbox_eq(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * shortestline_tpose_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return shortestline_tpose_geo(temp, gs);
+int tpcbox_ne_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) tpcbox_ne(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * shortestline_tpose_pose_w(const Temporal * temp, const Pose * pose) {
-  return shortestline_tpose_pose(temp, pose);
+int tpcbox_lt_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) tpcbox_lt(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * shortestline_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) {
-  return shortestline_tpose_tpose(temp1, temp2);
+int tpcbox_le_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) tpcbox_le(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_eq_pose_tpose_w(const Pose * pose, const Temporal * temp) {
-  return always_eq_pose_tpose(pose, temp);
+int tpcbox_gt_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) tpcbox_gt(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_eq_tpose_pose_w(const Temporal * temp, const Pose * pose) {
-  return always_eq_tpose_pose(temp, pose);
+int tpcbox_ge_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) tpcbox_ge(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_eq_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) {
-  return always_eq_tpose_tpose(temp1, temp2);
+int left_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) left_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_ne_pose_tpose_w(const Pose * pose, const Temporal * temp) {
-  return always_ne_pose_tpose(pose, temp);
+int overleft_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) overleft_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_ne_tpose_pose_w(const Temporal * temp, const Pose * pose) {
-  return always_ne_tpose_pose(temp, pose);
+int right_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) right_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_ne_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) {
-  return always_ne_tpose_tpose(temp1, temp2);
+int overright_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) overright_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_eq_pose_tpose_w(const Pose * pose, const Temporal * temp) {
-  return ever_eq_pose_tpose(pose, temp);
+int below_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) below_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_eq_tpose_pose_w(const Temporal * temp, const Pose * pose) {
-  return ever_eq_tpose_pose(temp, pose);
+int overbelow_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) overbelow_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_eq_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) {
-  return ever_eq_tpose_tpose(temp1, temp2);
+int above_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) above_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_ne_pose_tpose_w(const Pose * pose, const Temporal * temp) {
-  return ever_ne_pose_tpose(pose, temp);
+int overabove_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) overabove_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_ne_tpose_pose_w(const Temporal * temp, const Pose * pose) {
-  return ever_ne_tpose_pose(temp, pose);
+int front_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) front_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_ne_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) {
-  return ever_ne_tpose_tpose(temp1, temp2);
+int overfront_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) overfront_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * teq_pose_tpose_w(const Pose * pose, const Temporal * temp) {
-  return teq_pose_tpose(pose, temp);
+int back_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) back_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * teq_tpose_pose_w(const Temporal * temp, const Pose * pose) {
-  return teq_tpose_pose(temp, pose);
+int overback_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) overback_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tne_pose_tpose_w(const Pose * pose, const Temporal * temp) {
-  return tne_pose_tpose(pose, temp);
+int before_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) before_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tne_tpose_pose_w(const Temporal * temp, const Pose * pose) {
-  return tne_tpose_pose(temp, pose);
+int overbefore_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) overbefore_tpcbox_tpcbox(box1, box2);
 }
 
-
-/* === meos_quadbin.h === */
-
 EMSCRIPTEN_KEEPALIVE
-uint64_t quadbin_in_w(const char * str) {
-  return quadbin_in(str);
+int after_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) after_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int quadbin_eq_w(uint64_t a, uint64_t b) {
-  return (int) quadbin_eq(a, b);
+int overafter_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) {
+  return (int) overafter_tpcbox_tpcbox(box1, box2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int quadbin_ne_w(uint64_t a, uint64_t b) {
-  return (int) quadbin_ne(a, b);
+Temporal * tpointcloud_to_tgeompoint_w(const Temporal * temp) {
+  return tpointcloud_to_tgeompoint(temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int quadbin_lt_w(uint64_t a, uint64_t b) {
-  return (int) quadbin_lt(a, b);
+Temporal * tpcpatch_to_tgeometry_w(const Temporal * temp) {
+  return tpcpatch_to_tgeometry(temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int quadbin_le_w(uint64_t a, uint64_t b) {
-  return (int) quadbin_le(a, b);
+TInstant * tpcpointinst_make_w(const Pcpoint * pt, long long t) {
+  return tpcpointinst_make(pt, (TimestampTz) t);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int quadbin_gt_w(uint64_t a, uint64_t b) {
-  return (int) quadbin_gt(a, b);
+TSequence * tpcpointseq_from_base_tstzset_w(const Pcpoint * pt, const Set * s) {
+  return tpcpointseq_from_base_tstzset(pt, s);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int quadbin_ge_w(uint64_t a, uint64_t b) {
-  return (int) quadbin_ge(a, b);
+TSequence * tpcpointseq_from_base_tstzspan_w(const Pcpoint * pt, const Span * sp) {
+  return tpcpointseq_from_base_tstzspan(pt, sp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int quadbin_cmp_w(uint64_t a, uint64_t b) {
-  return quadbin_cmp(a, b);
+TSequenceSet * tpcpointseqset_from_base_tstzspanset_w(const Pcpoint * pt, const SpanSet * ss) {
+  return tpcpointseqset_from_base_tstzspanset(pt, ss);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint32_t quadbin_hash_w(uint64_t cell) {
-  return quadbin_hash(cell);
+Temporal * tpcpoint_from_base_temp_w(const Pcpoint * pt, const Temporal * temp) {
+  return tpcpoint_from_base_temp(pt, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint64_t quadbin_hash_extended_w(uint64_t cell, uint64_t seed) {
-  return quadbin_hash_extended(cell, seed);
+Pcpoint * tpcpoint_start_value_w(const Temporal * temp) {
+  return tpcpoint_start_value(temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int quadbin_is_valid_index_w(uint64_t index) {
-  return (int) quadbin_is_valid_index(index);
+Pcpoint * tpcpoint_end_value_w(const Temporal * temp) {
+  return tpcpoint_end_value(temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int quadbin_is_valid_cell_w(uint64_t cell) {
-  return (int) quadbin_is_valid_cell(cell);
+Pcpoint * tpcpoint_value_n_w(const Temporal * temp, int n) {
+  Pcpoint * r;
+  if (!tpcpoint_value_n(temp, n, &r)) return NULL;
+  return r;
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint64_t quadbin_tile_to_cell_w(uint32_t x, uint32_t y, uint32_t z) {
-  return quadbin_tile_to_cell(x, y, z);
+Pcpoint ** tpcpoint_values_w(const Temporal * temp, int * count) {
+  return tpcpoint_values(temp, count);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int quadbin_cell_to_tile_w(uint64_t cell, uint32_t * x, uint32_t * y, uint32_t * z) {
-  return (int) quadbin_cell_to_tile(cell, x, y, z);
+int tpcpoint_value_at_timestamptz_w(const Temporal * temp, long long t, int strict, Pcpoint ** value) {
+  return (int) tpcpoint_value_at_timestamptz(temp, (TimestampTz) t, (bool) strict, value);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint32_t quadbin_get_resolution_w(uint64_t cell) {
-  return quadbin_get_resolution(cell);
+Temporal * tpcpoint_at_value_w(const Temporal * temp, const Pcpoint * pt) {
+  return tpcpoint_at_value(temp, pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint64_t quadbin_cell_to_parent_w(uint64_t cell, uint32_t parent_resolution) {
-  return quadbin_cell_to_parent(cell, parent_resolution);
+Temporal * tpcpoint_minus_value_w(const Temporal * temp, const Pcpoint * pt) {
+  return tpcpoint_minus_value(temp, pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint64_t * quadbin_cell_to_children_w(uint64_t cell, uint32_t children_resolution, int * count) {
-  return quadbin_cell_to_children(cell, children_resolution, count);
+TInstant * tpcpatchinst_make_w(const Pcpatch * pa, long long t) {
+  return tpcpatchinst_make(pa, (TimestampTz) t);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint64_t quadbin_cell_sibling_w(uint64_t cell, const char * direction) {
-  return quadbin_cell_sibling(cell, direction);
+TSequence * tpcpatchseq_from_base_tstzset_w(const Pcpatch * pa, const Set * s) {
+  return tpcpatchseq_from_base_tstzset(pa, s);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint64_t * quadbin_k_ring_w(uint64_t cell, int k, int * count) {
-  return quadbin_k_ring(cell, k, count);
+TSequence * tpcpatchseq_from_base_tstzspan_w(const Pcpatch * pa, const Span * sp) {
+  return tpcpatchseq_from_base_tstzspan(pa, sp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint64_t quadbin_point_to_cell_w(double longitude, double latitude, uint32_t resolution) {
-  return quadbin_point_to_cell(longitude, latitude, resolution);
+TSequenceSet * tpcpatchseqset_from_base_tstzspanset_w(const Pcpatch * pa, const SpanSet * ss) {
+  return tpcpatchseqset_from_base_tstzspanset(pa, ss);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint64_t geo_to_quadbin_cell_w(const GSERIALIZED * point, int32 resolution) {
-  return geo_to_quadbin_cell(point, resolution);
+Temporal * tpcpatch_from_base_temp_w(const Pcpatch * pa, const Temporal * temp) {
+  return tpcpatch_from_base_temp(pa, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * quadbin_cell_to_geompoint_w(uint64_t cell) {
-  return quadbin_cell_to_geompoint(cell);
+Pcpatch * tpcpatch_start_value_w(const Temporal * temp) {
+  return tpcpatch_start_value(temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * quadbin_cell_to_geom_w(uint64_t cell) {
-  return quadbin_cell_to_geom(cell);
+Pcpatch * tpcpatch_end_value_w(const Temporal * temp) {
+  return tpcpatch_end_value(temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-STBox * quadbin_to_stbox_w(uint64_t cell) {
-  return quadbin_to_stbox(cell);
+Pcpatch * tpcpatch_value_n_w(const Temporal * temp, int n) {
+  Pcpatch * r;
+  if (!tpcpatch_value_n(temp, n, &r)) return NULL;
+  return r;
 }
 
 EMSCRIPTEN_KEEPALIVE
-STBox * quadbin_timestamptz_to_stbox_w(uint64_t cell, long long t) {
-  return quadbin_timestamptz_to_stbox(cell, (TimestampTz) t);
+Pcpatch ** tpcpatch_values_w(const Temporal * temp, int * count) {
+  return tpcpatch_values(temp, count);
 }
 
 EMSCRIPTEN_KEEPALIVE
-STBox * quadbin_tstzspan_to_stbox_w(uint64_t cell, const Span * s) {
-  return quadbin_tstzspan_to_stbox(cell, s);
+int tpcpatch_value_at_timestamptz_w(const Temporal * temp, long long t, int strict, Pcpatch ** value) {
+  return (int) tpcpatch_value_at_timestamptz(temp, (TimestampTz) t, (bool) strict, value);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double quadbin_cell_area_w(uint64_t cell) {
-  return quadbin_cell_area(cell);
+Temporal * tpcpatch_at_value_w(const Temporal * temp, const Pcpatch * pa) {
+  return tpcpatch_at_value(temp, pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-char * quadbin_index_to_string_w(uint64_t index) {
-  return quadbin_index_to_string(index);
+Temporal * tpcpatch_minus_value_w(const Temporal * temp, const Pcpatch * pa) {
+  return tpcpatch_minus_value(temp, pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint64_t quadbin_string_to_index_w(const char * str) {
-  return quadbin_string_to_index(str);
+int ever_eq_pcpoint_tpcpoint_w(const Pcpoint * pt, const Temporal * temp) {
+  return ever_eq_pcpoint_tpcpoint(pt, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-char * quadbin_cell_to_quadkey_w(uint64_t cell) {
-  return quadbin_cell_to_quadkey(cell);
+int ever_eq_tpcpoint_pcpoint_w(const Temporal * temp, const Pcpoint * pt) {
+  return ever_eq_tpcpoint_pcpoint(temp, pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Set * quadbin_grid_disk_w(uint64_t origin, int k) {
-  return quadbin_grid_disk(origin, k);
+int ever_eq_tpcpoint_tpcpoint_w(const Temporal * temp1, const Temporal * temp2) {
+  return ever_eq_tpcpoint_tpcpoint(temp1, temp2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Set * quadbin_cell_to_children_set_w(uint64_t origin, int children_resolution) {
-  return quadbin_cell_to_children_set(origin, children_resolution);
+int ever_ne_pcpoint_tpcpoint_w(const Pcpoint * pt, const Temporal * temp) {
+  return ever_ne_pcpoint_tpcpoint(pt, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tquadbin_in_w(const char * str) {
-  return tquadbin_in(str);
+int ever_ne_tpcpoint_pcpoint_w(const Temporal * temp, const Pcpoint * pt) {
+  return ever_ne_tpcpoint_pcpoint(temp, pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TInstant * tquadbininst_in_w(const char * str) {
-  return tquadbininst_in(str);
+int ever_ne_tpcpoint_tpcpoint_w(const Temporal * temp1, const Temporal * temp2) {
+  return ever_ne_tpcpoint_tpcpoint(temp1, temp2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequence * tquadbinseq_in_w(const char * str, interpType interp) {
-  return tquadbinseq_in(str, interp);
+int always_eq_pcpoint_tpcpoint_w(const Pcpoint * pt, const Temporal * temp) {
+  return always_eq_pcpoint_tpcpoint(pt, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequenceSet * tquadbinseqset_in_w(const char * str) {
-  return tquadbinseqset_in(str);
+int always_eq_tpcpoint_pcpoint_w(const Temporal * temp, const Pcpoint * pt) {
+  return always_eq_tpcpoint_pcpoint(temp, pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tquadbin_make_w(uint64_t value, long long t) {
-  return tquadbin_make(value, (TimestampTz) t);
+int always_eq_tpcpoint_tpcpoint_w(const Temporal * temp1, const Temporal * temp2) {
+  return always_eq_tpcpoint_tpcpoint(temp1, temp2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TInstant * tquadbininst_make_w(uint64_t value, long long t) {
-  return tquadbininst_make(value, (TimestampTz) t);
+int always_ne_pcpoint_tpcpoint_w(const Pcpoint * pt, const Temporal * temp) {
+  return always_ne_pcpoint_tpcpoint(pt, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequence * tquadbinseq_make_w(const uint64_t * values, const TimestampTz * times, int count, int lower_inc, int upper_inc) {
-  return tquadbinseq_make(values, times, count, (bool) lower_inc, (bool) upper_inc);
+int always_ne_tpcpoint_pcpoint_w(const Temporal * temp, const Pcpoint * pt) {
+  return always_ne_tpcpoint_pcpoint(temp, pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequenceSet * tquadbinseqset_make_w(const TSequence ** sequences, int count) {
-  return tquadbinseqset_make(sequences, count);
+int always_ne_tpcpoint_tpcpoint_w(const Temporal * temp1, const Temporal * temp2) {
+  return always_ne_tpcpoint_tpcpoint(temp1, temp2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint64_t tquadbin_start_value_w(const Temporal * temp) {
-  return tquadbin_start_value(temp);
+int ever_eq_pcpatch_tpcpatch_w(const Pcpatch * pa, const Temporal * temp) {
+  return ever_eq_pcpatch_tpcpatch(pa, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint64_t tquadbin_end_value_w(const Temporal * temp) {
-  return tquadbin_end_value(temp);
+int ever_eq_tpcpatch_pcpatch_w(const Temporal * temp, const Pcpatch * pa) {
+  return ever_eq_tpcpatch_pcpatch(temp, pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-long long tquadbin_value_n_w(const Temporal * temp, int n) {
-  uint64_t r;
-  if (!tquadbin_value_n(temp, n, &r)) return 0;
-  return (long long) r;
+int ever_eq_tpcpatch_tpcpatch_w(const Temporal * temp1, const Temporal * temp2) {
+  return ever_eq_tpcpatch_tpcpatch(temp1, temp2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint64_t * tquadbin_values_w(const Temporal * temp, int * count) {
-  return tquadbin_values(temp, count);
+int ever_ne_pcpatch_tpcpatch_w(const Pcpatch * pa, const Temporal * temp) {
+  return ever_ne_pcpatch_tpcpatch(pa, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-long long tquadbin_value_at_timestamptz_w(const Temporal * temp, long long t, int strict) {
-  uint64_t r;
-  if (!tquadbin_value_at_timestamptz(temp, (TimestampTz) t, (bool) strict, &r)) return 0;
-  return (long long) r;
+int ever_ne_tpcpatch_pcpatch_w(const Temporal * temp, const Pcpatch * pa) {
+  return ever_ne_tpcpatch_pcpatch(temp, pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Set * quadbin_to_set_w(uint64_t cell) {
-  return quadbin_to_set(cell);
+int ever_ne_tpcpatch_tpcpatch_w(const Temporal * temp1, const Temporal * temp2) {
+  return ever_ne_tpcpatch_tpcpatch(temp1, temp2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tbigint_to_tquadbin_w(const Temporal * temp) {
-  return tbigint_to_tquadbin(temp);
+int always_eq_pcpatch_tpcpatch_w(const Pcpatch * pa, const Temporal * temp) {
+  return always_eq_pcpatch_tpcpatch(pa, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tquadbin_to_tbigint_w(const Temporal * temp) {
-  return tquadbin_to_tbigint(temp);
+int always_eq_tpcpatch_pcpatch_w(const Temporal * temp, const Pcpatch * pa) {
+  return always_eq_tpcpatch_pcpatch(temp, pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_eq_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) {
-  return ever_eq_quadbin_tquadbin(cell, temp);
+int always_eq_tpcpatch_tpcpatch_w(const Temporal * temp1, const Temporal * temp2) {
+  return always_eq_tpcpatch_tpcpatch(temp1, temp2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_eq_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) {
-  return ever_eq_tquadbin_quadbin(temp, cell);
+int always_ne_pcpatch_tpcpatch_w(const Pcpatch * pa, const Temporal * temp) {
+  return always_ne_pcpatch_tpcpatch(pa, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_ne_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) {
-  return ever_ne_quadbin_tquadbin(cell, temp);
+int always_ne_tpcpatch_pcpatch_w(const Temporal * temp, const Pcpatch * pa) {
+  return always_ne_tpcpatch_pcpatch(temp, pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_ne_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) {
-  return ever_ne_tquadbin_quadbin(temp, cell);
+int always_ne_tpcpatch_tpcpatch_w(const Temporal * temp1, const Temporal * temp2) {
+  return always_ne_tpcpatch_tpcpatch(temp1, temp2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_eq_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) {
-  return always_eq_quadbin_tquadbin(cell, temp);
+Temporal * teq_pcpoint_tpcpoint_w(const Pcpoint * pt, const Temporal * temp) {
+  return teq_pcpoint_tpcpoint(pt, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_eq_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) {
-  return always_eq_tquadbin_quadbin(temp, cell);
+Temporal * teq_tpcpoint_pcpoint_w(const Temporal * temp, const Pcpoint * pt) {
+  return teq_tpcpoint_pcpoint(temp, pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_ne_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) {
-  return always_ne_quadbin_tquadbin(cell, temp);
+Temporal * tne_pcpoint_tpcpoint_w(const Pcpoint * pt, const Temporal * temp) {
+  return tne_pcpoint_tpcpoint(pt, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_ne_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) {
-  return always_ne_tquadbin_quadbin(temp, cell);
+Temporal * tne_tpcpoint_pcpoint_w(const Temporal * temp, const Pcpoint * pt) {
+  return tne_tpcpoint_pcpoint(temp, pt);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_eq_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) {
-  return ever_eq_tquadbin_tquadbin(temp1, temp2);
+Temporal * teq_pcpatch_tpcpatch_w(const Pcpatch * pa, const Temporal * temp) {
+  return teq_pcpatch_tpcpatch(pa, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_ne_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) {
-  return ever_ne_tquadbin_tquadbin(temp1, temp2);
+Temporal * teq_tpcpatch_pcpatch_w(const Temporal * temp, const Pcpatch * pa) {
+  return teq_tpcpatch_pcpatch(temp, pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_eq_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) {
-  return always_eq_tquadbin_tquadbin(temp1, temp2);
+Temporal * tne_pcpatch_tpcpatch_w(const Pcpatch * pa, const Temporal * temp) {
+  return tne_pcpatch_tpcpatch(pa, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_ne_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) {
-  return always_ne_tquadbin_tquadbin(temp1, temp2);
+Temporal * tne_tpcpatch_pcpatch_w(const Temporal * temp, const Pcpatch * pa) {
+  return tne_tpcpatch_pcpatch(temp, pa);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * teq_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) {
-  return teq_quadbin_tquadbin(cell, temp);
+int adjacent_tpcbox_tpointcloud_w(const TPCBox * box, const Temporal * temp) {
+  return (int) adjacent_tpcbox_tpointcloud(box, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * teq_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) {
-  return teq_tquadbin_quadbin(temp, cell);
+int adjacent_tpointcloud_tpcbox_w(const Temporal * temp, const TPCBox * box) {
+  return (int) adjacent_tpointcloud_tpcbox(temp, box);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * teq_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) {
-  return teq_tquadbin_tquadbin(temp1, temp2);
+int adjacent_tpointcloud_tpointcloud_w(const Temporal * temp1, const Temporal * temp2) {
+  return (int) adjacent_tpointcloud_tpointcloud(temp1, temp2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tne_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) {
-  return tne_quadbin_tquadbin(cell, temp);
+int contained_tpcbox_tpointcloud_w(const TPCBox * box, const Temporal * temp) {
+  return (int) contained_tpcbox_tpointcloud(box, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tne_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) {
-  return tne_tquadbin_quadbin(temp, cell);
+int contained_tpointcloud_tpcbox_w(const Temporal * temp, const TPCBox * box) {
+  return (int) contained_tpointcloud_tpcbox(temp, box);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tne_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) {
-  return tne_tquadbin_tquadbin(temp1, temp2);
+int contained_tpointcloud_tpointcloud_w(const Temporal * temp1, const Temporal * temp2) {
+  return (int) contained_tpointcloud_tpointcloud(temp1, temp2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tquadbin_cell_to_quadkey_w(const Temporal * temp) {
-  return tquadbin_cell_to_quadkey(temp);
+int contains_tpcbox_tpointcloud_w(const TPCBox * box, const Temporal * temp) {
+  return (int) contains_tpcbox_tpointcloud(box, temp);
 }
 
-
-/* === meos_rgeo.h === */
+EMSCRIPTEN_KEEPALIVE
+int contains_tpointcloud_tpcbox_w(const Temporal * temp, const TPCBox * box) {
+  return (int) contains_tpointcloud_tpcbox(temp, box);
+}
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_in_w(const char * str) {
-  return trgeometry_in(str);
+int contains_tpointcloud_tpointcloud_w(const Temporal * temp1, const Temporal * temp2) {
+  return (int) contains_tpointcloud_tpointcloud(temp1, temp2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_from_mfjson_w(const char * mfjson) {
-  return trgeometry_from_mfjson(mfjson);
+int overlaps_tpcbox_tpointcloud_w(const TPCBox * box, const Temporal * temp) {
+  return (int) overlaps_tpcbox_tpointcloud(box, temp);
 }
 
 EMSCRIPTEN_KEEPALIVE
-char * trgeometry_out_w(const Temporal * temp) {
-  return trgeometry_out(temp);
+int overlaps_tpointcloud_tpcbox_w(const Temporal * temp, const TPCBox * box) {
+  return (int) overlaps_tpointcloud_tpcbox(temp, box);
 }
 
 EMSCRIPTEN_KEEPALIVE
-char * trgeometry_as_text_w(const Temporal * temp, int maxdd) {
-  return trgeometry_as_text(temp, maxdd);
+int overlaps_tpointcloud_tpointcloud_w(const Temporal * temp1, const Temporal * temp2) {
+  return (int) overlaps_tpointcloud_tpointcloud(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int same_tpcbox_tpointcloud_w(const TPCBox * box, const Temporal * temp) {
+  return (int) same_tpcbox_tpointcloud(box, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int same_tpointcloud_tpcbox_w(const Temporal * temp, const TPCBox * box) {
+  return (int) same_tpointcloud_tpcbox(temp, box);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int same_tpointcloud_tpointcloud_w(const Temporal * temp1, const Temporal * temp2) {
+  return (int) same_tpointcloud_tpointcloud(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int eintersects_tpcpoint_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return (int) eintersects_tpcpoint_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double nad_tpcpoint_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return nad_tpcpoint_geo(temp, gs);
+}
+
+
+/* === meos_pose.h === */
+
+EMSCRIPTEN_KEEPALIVE
+char * pose_as_ewkt_w(const Pose * pose, int maxdd) {
+  return pose_as_ewkt(pose, maxdd);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * pose_as_hexwkb_w(const Pose * pose, uint8_t variant, size_t * size_out) {
+  return pose_as_hexwkb(pose, variant, size_out);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * pose_as_text_w(const Pose * pose, int maxdd) {
+  return pose_as_text(pose, maxdd);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint8_t * pose_as_wkb_w(const Pose * pose, uint8_t variant, size_t * size_out) {
+  return pose_as_wkb(pose, variant, size_out);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_from_wkb_w(const uint8_t * wkb, size_t size) {
+  return pose_from_wkb(wkb, size);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_from_hexwkb_w(const char * hexwkb) {
+  return pose_from_hexwkb(hexwkb);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_in_w(const char * str) {
+  return pose_in(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * pose_out_w(const Pose * pose, int maxdd) {
+  return pose_out(pose, maxdd);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_from_geopose_w(const char * json) {
+  return pose_from_geopose(json);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * pose_as_geopose_w(const Pose * pose, int conformance, int precision) {
+  return pose_as_geopose(pose, conformance, precision);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_from_geopose_w(const char * json) {
+  return tpose_from_geopose(json);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * tpose_as_geopose_w(const Temporal * temp, int conformance, int precision) {
+  return tpose_as_geopose(temp, conformance, precision);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * tpose_as_geopose_stream_element_w(const Temporal * temp, const TInstant * inst, int precision) {
+  return tpose_as_geopose_stream_element(temp, inst, precision);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * tpose_as_geopose_stream_w(const Temporal * temp, int precision) {
+  return tpose_as_geopose_stream(temp, precision);
+}
+
+EMSCRIPTEN_KEEPALIVE
+const GeoPoseFrame * geopose_frames_w(int * count) {
+  return geopose_frames(count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+const GeoPoseFrame * geopose_frame_w(int32_t frame_id) {
+  return geopose_frame(frame_id);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * pose_apply_geo_w(const Pose * pose, const GSERIALIZED * body) {
+  return pose_apply_geo(pose, body);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_apply_geo_w(const Temporal * temp, const GSERIALIZED * body) {
+  return tpose_apply_geo(temp, body);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_compose_pose_w(const Temporal * body, const Pose * frame) {
+  return tpose_compose_pose(body, frame);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * pose_compose_tpose_w(const Pose * body, const Temporal * frame) {
+  return pose_compose_tpose(body, frame);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_compose_tpose_w(const Temporal * body, const Temporal * frame) {
+  return tpose_compose_tpose(body, frame);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_inverse_w(const Temporal * temp) {
+  return tpose_inverse(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_copy_w(const Pose * pose) {
+  return pose_copy(pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_make_2d_w(double x, double y, double theta, int geodetic, int32_t srid) {
+  return pose_make_2d(x, y, theta, (bool) geodetic, srid);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_make_3d_w(double x, double y, double z, double W, double X, double Y, double Z, int geodetic, int32_t srid) {
+  return pose_make_3d(x, y, z, W, X, Y, Z, (bool) geodetic, srid);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_make_point2d_w(const GSERIALIZED * gs, double theta) {
+  return pose_make_point2d(gs, theta);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_make_point3d_w(const GSERIALIZED * gs, double W, double X, double Y, double Z) {
+  return pose_make_point3d(gs, W, X, Y, Z);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_make_point3d_ypr_w(const GSERIALIZED * gs, double yaw, double pitch, double roll) {
+  return pose_make_point3d_ypr(gs, yaw, pitch, roll);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * pose_to_point_w(const Pose * pose) {
+  return pose_to_point(pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * pose_to_stbox_w(const Pose * pose) {
+  return pose_to_stbox(pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint32_t pose_hash_w(const Pose * pose) {
+  return pose_hash(pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t pose_hash_extended_w(const Pose * pose, uint64_t seed) {
+  return pose_hash_extended(pose, seed);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double * pose_quaternion_w(const Pose * pose, int * count) {
+  return pose_quaternion(pose, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double * pose_ypr_w(const Pose * pose, int * count) {
+  return pose_ypr(pose, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double pose_yaw_w(const Pose * pose) {
+  return pose_yaw(pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double pose_pitch_w(const Pose * pose) {
+  return pose_pitch(pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double pose_roll_w(const Pose * pose) {
+  return pose_roll(pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double pose_angular_distance_w(const Pose * pose1, const Pose * pose2) {
+  return pose_angular_distance(pose1, pose2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_compose_w(const Pose * body, const Pose * frame) {
+  return pose_compose(body, frame);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_inverse_w(const Pose * pose) {
+  return pose_inverse(pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_normalize_w(const Pose * pose) {
+  return pose_normalize(pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_round_w(const Pose * pose, int maxdd) {
+  return pose_round(pose, maxdd);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose ** posearr_round_w(const Pose ** posearr, int count, int maxdd) {
+  return posearr_round(posearr, count, maxdd);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_set_srid_w(const Pose * pose, int32_t srid) {
+  return pose_set_srid(pose, srid);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int32_t pose_srid_w(const Pose * pose) {
+  return pose_srid(pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_transform_w(const Pose * pose, int32_t srid) {
+  return pose_transform(pose, srid);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * pose_transform_pipeline_w(const Pose * pose, const char * pipelinestr, int32_t srid, int is_forward) {
+  return pose_transform_pipeline(pose, pipelinestr, srid, (bool) is_forward);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * pose_tstzspan_to_stbox_w(const Pose * pose, const Span * s) {
+  return pose_tstzspan_to_stbox(pose, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * pose_timestamptz_to_stbox_w(const Pose * pose, long long t) {
+  return pose_timestamptz_to_stbox(pose, (TimestampTz) t);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double distance_pose_geo_w(const Pose * pose, const GSERIALIZED * gs) {
+  return distance_pose_geo(pose, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double distance_pose_pose_w(const Pose * pose1, const Pose * pose2) {
+  return distance_pose_pose(pose1, pose2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double distance_pose_stbox_w(const Pose * pose, const STBox * box) {
+  return distance_pose_stbox(pose, box);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int pose_cmp_w(const Pose * pose1, const Pose * pose2) {
+  return pose_cmp(pose1, pose2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int pose_eq_w(const Pose * pose1, const Pose * pose2) {
+  return (int) pose_eq(pose1, pose2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int pose_ge_w(const Pose * pose1, const Pose * pose2) {
+  return (int) pose_ge(pose1, pose2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int pose_gt_w(const Pose * pose1, const Pose * pose2) {
+  return (int) pose_gt(pose1, pose2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int pose_le_w(const Pose * pose1, const Pose * pose2) {
+  return (int) pose_le(pose1, pose2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int pose_lt_w(const Pose * pose1, const Pose * pose2) {
+  return (int) pose_lt(pose1, pose2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int pose_ne_w(const Pose * pose1, const Pose * pose2) {
+  return (int) pose_ne(pose1, pose2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int pose_nsame_w(const Pose * pose1, const Pose * pose2) {
+  return (int) pose_nsame(pose1, pose2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int pose_same_w(const Pose * pose1, const Pose * pose2) {
+  return (int) pose_same(pose1, pose2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * poseset_in_w(const char * str) {
+  return poseset_in(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * poseset_out_w(const Set * s, int maxdd) {
+  return poseset_out(s, maxdd);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * poseset_make_w(const Pose ** values, int count) {
+  return poseset_make(values, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * pose_to_set_w(const Pose * pose) {
+  return pose_to_set(pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * poseset_end_value_w(const Set * s) {
+  return poseset_end_value(s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * poseset_start_value_w(const Set * s) {
+  return poseset_start_value(s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * poseset_value_n_w(const Set * s, int n) {
+  Pose * r;
+  if (!poseset_value_n(s, n, &r)) return NULL;
+  return r;
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose ** poseset_values_w(const Set * s, int * count) {
+  return poseset_values(s, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int contained_pose_set_w(const Pose * pose, const Set * s) {
+  return (int) contained_pose_set(pose, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int contains_set_pose_w(const Set * s, Pose * pose) {
+  return (int) contains_set_pose(s, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * intersection_pose_set_w(const Pose * pose, const Set * s) {
+  return intersection_pose_set(pose, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * intersection_set_pose_w(const Set * s, const Pose * pose) {
+  return intersection_set_pose(s, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * minus_pose_set_w(const Pose * pose, const Set * s) {
+  return minus_pose_set(pose, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * minus_set_pose_w(const Set * s, const Pose * pose) {
+  return minus_set_pose(s, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * pose_union_transfn_w(Set * state, const Pose * pose) {
+  return pose_union_transfn(state, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * union_pose_set_w(const Pose * pose, const Set * s) {
+  return union_pose_set(pose, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * union_set_pose_w(const Set * s, const Pose * pose) {
+  return union_set_pose(s, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_from_mfjson_w(const char * str) {
+  return tpose_from_mfjson(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_in_w(const char * str) {
+  return tpose_in(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TInstant * tposeinst_make_w(const Pose * pose, long long t) {
+  return tposeinst_make(pose, (TimestampTz) t);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_from_base_temp_w(const Pose * pose, const Temporal * temp) {
+  return tpose_from_base_temp(pose, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequence * tposeseq_from_base_tstzset_w(const Pose * pose, const Set * s) {
+  return tposeseq_from_base_tstzset(pose, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequence * tposeseq_from_base_tstzspan_w(const Pose * pose, const Span * s, interpType interp) {
+  return tposeseq_from_base_tstzspan(pose, s, interp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequenceSet * tposeseqset_from_base_tstzspanset_w(const Pose * pose, const SpanSet * ss, interpType interp) {
+  return tposeseqset_from_base_tstzspanset(pose, ss, interp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_make_w(const Temporal * tpoint, const Temporal * ttheta) {
+  return tpose_make(tpoint, ttheta);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_to_tpoint_w(const Temporal * temp) {
+  return tpose_to_tpoint(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * tpose_end_value_w(const Temporal * temp) {
+  return tpose_end_value(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * tpose_points_w(const Temporal * temp) {
+  return tpose_points(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_yaw_w(const Temporal * temp) {
+  return tpose_yaw(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_pitch_w(const Temporal * temp) {
+  return tpose_pitch(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_roll_w(const Temporal * temp) {
+  return tpose_roll(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_speed_w(const Temporal * temp) {
+  return tpose_speed(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_angular_speed_w(const Temporal * temp) {
+  return tpose_angular_speed(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * tpose_start_value_w(const Temporal * temp) {
+  return tpose_start_value(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * tpose_trajectory_w(const Temporal * temp) {
+  return tpose_trajectory(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * tpose_value_at_timestamptz_w(const Temporal * temp, long long t, int strict) {
+  Pose * r;
+  if (!tpose_value_at_timestamptz(temp, (TimestampTz) t, (bool) strict, &r)) return NULL;
+  return r;
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * tpose_value_n_w(const Temporal * temp, int n) {
+  Pose * r;
+  if (!tpose_value_n(temp, n, &r)) return NULL;
+  return r;
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose ** tpose_values_w(const Temporal * temp, int * count) {
+  return tpose_values(temp, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_at_elevation_w(const Temporal * temp, const Span * s) {
+  return tpose_at_elevation(temp, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_at_geom_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return tpose_at_geom(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_at_stbox_w(const Temporal * temp, const STBox * box, int border_inc) {
+  return tpose_at_stbox(temp, box, (bool) border_inc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_at_pose_w(const Temporal * temp, const Pose * pose) {
+  return tpose_at_pose(temp, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_minus_elevation_w(const Temporal * temp, const Span * s) {
+  return tpose_minus_elevation(temp, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_minus_geom_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return tpose_minus_geom(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_minus_pose_w(const Temporal * temp, const Pose * pose) {
+  return tpose_minus_pose(temp, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tpose_minus_stbox_w(const Temporal * temp, const STBox * box, int border_inc) {
+  return tpose_minus_stbox(temp, box, (bool) border_inc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tdistance_tpose_pose_w(const Temporal * temp, const Pose * pose) {
+  return tdistance_tpose_pose(temp, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tdistance_tpose_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return tdistance_tpose_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tdistance_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) {
+  return tdistance_tpose_tpose(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double nad_tpose_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return nad_tpose_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double nad_tpose_pose_w(const Temporal * temp, const Pose * pose) {
+  return nad_tpose_pose(temp, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double nad_tpose_stbox_w(const Temporal * temp, const STBox * box) {
+  return nad_tpose_stbox(temp, box);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double nad_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) {
+  return nad_tpose_tpose(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TInstant * nai_tpose_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return nai_tpose_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TInstant * nai_tpose_pose_w(const Temporal * temp, const Pose * pose) {
+  return nai_tpose_pose(temp, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TInstant * nai_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) {
+  return nai_tpose_tpose(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * shortestline_tpose_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return shortestline_tpose_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * shortestline_tpose_pose_w(const Temporal * temp, const Pose * pose) {
+  return shortestline_tpose_pose(temp, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * shortestline_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) {
+  return shortestline_tpose_tpose(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_eq_pose_tpose_w(const Pose * pose, const Temporal * temp) {
+  return always_eq_pose_tpose(pose, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_eq_tpose_pose_w(const Temporal * temp, const Pose * pose) {
+  return always_eq_tpose_pose(temp, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_eq_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) {
+  return always_eq_tpose_tpose(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_ne_pose_tpose_w(const Pose * pose, const Temporal * temp) {
+  return always_ne_pose_tpose(pose, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_ne_tpose_pose_w(const Temporal * temp, const Pose * pose) {
+  return always_ne_tpose_pose(temp, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_ne_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) {
+  return always_ne_tpose_tpose(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_eq_pose_tpose_w(const Pose * pose, const Temporal * temp) {
+  return ever_eq_pose_tpose(pose, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_eq_tpose_pose_w(const Temporal * temp, const Pose * pose) {
+  return ever_eq_tpose_pose(temp, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_eq_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) {
+  return ever_eq_tpose_tpose(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_ne_pose_tpose_w(const Pose * pose, const Temporal * temp) {
+  return ever_ne_pose_tpose(pose, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_ne_tpose_pose_w(const Temporal * temp, const Pose * pose) {
+  return ever_ne_tpose_pose(temp, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_ne_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) {
+  return ever_ne_tpose_tpose(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * teq_pose_tpose_w(const Pose * pose, const Temporal * temp) {
+  return teq_pose_tpose(pose, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * teq_tpose_pose_w(const Temporal * temp, const Pose * pose) {
+  return teq_tpose_pose(temp, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tne_pose_tpose_w(const Pose * pose, const Temporal * temp) {
+  return tne_pose_tpose(pose, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tne_tpose_pose_w(const Temporal * temp, const Pose * pose) {
+  return tne_tpose_pose(temp, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+PoseChain * posechain_in_w(const char * str) {
+  return posechain_in(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * posechain_out_w(const PoseChain * pc, int maxdd) {
+  return posechain_out(pc, maxdd);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * posechain_as_text_w(const PoseChain * pc, int maxdd) {
+  return posechain_as_text(pc, maxdd);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * posechain_as_ewkt_w(const PoseChain * pc, int maxdd) {
+  return posechain_as_ewkt(pc, maxdd);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint8_t * posechain_as_wkb_w(const PoseChain * pc, uint8_t variant, size_t * size_out) {
+  return posechain_as_wkb(pc, variant, size_out);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * posechain_as_hexwkb_w(const PoseChain * pc, uint8_t variant, size_t * size_out) {
+  return posechain_as_hexwkb(pc, variant, size_out);
+}
+
+EMSCRIPTEN_KEEPALIVE
+PoseChain * posechain_from_wkb_w(const uint8_t * wkb, size_t size) {
+  return posechain_from_wkb(wkb, size);
+}
+
+EMSCRIPTEN_KEEPALIVE
+PoseChain * posechain_from_hexwkb_w(const char * hexwkb) {
+  return posechain_from_hexwkb(hexwkb);
+}
+
+EMSCRIPTEN_KEEPALIVE
+PoseChain * posechain_make_w(const Pose ** poses, int count) {
+  return posechain_make(poses, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+PoseChain * posechain_copy_w(const PoseChain * pc) {
+  return posechain_copy(pc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+PoseChain * posechain_append_w(const PoseChain * pc, const Pose * pose) {
+  return posechain_append(pc, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+PoseChain * pose_to_posechain_w(const Pose * pose) {
+  return pose_to_posechain(pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * posechain_to_pose_w(const PoseChain * pc) {
+  return posechain_to_pose(pc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * posechain_prefix_pose_w(const PoseChain * pc, int n) {
+  return posechain_prefix_pose(pc, n);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * posechain_to_point_w(const PoseChain * pc) {
+  return posechain_to_point(pc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * posechain_to_stbox_w(const PoseChain * pc) {
+  return posechain_to_stbox(pc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * posechain_timestamptz_to_stbox_w(const PoseChain * pc, long long t) {
+  return posechain_timestamptz_to_stbox(pc, (TimestampTz) t);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * posechain_tstzspan_to_stbox_w(const PoseChain * pc, const Span * s) {
+  return posechain_tstzspan_to_stbox(pc, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int posechain_num_poses_w(const PoseChain * pc) {
+  return posechain_num_poses(pc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * posechain_start_pose_w(const PoseChain * pc) {
+  return posechain_start_pose(pc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * posechain_end_pose_w(const PoseChain * pc) {
+  return posechain_end_pose(pc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose * posechain_pose_n_w(const PoseChain * pc, int n) {
+  return posechain_pose_n(pc, n);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Pose ** posechain_poses_w(const PoseChain * pc, int * count) {
+  return posechain_poses(pc, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint32_t posechain_hash_w(const PoseChain * pc) {
+  return posechain_hash(pc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t posechain_hash_extended_w(const PoseChain * pc, uint64_t seed) {
+  return posechain_hash_extended(pc, seed);
+}
+
+EMSCRIPTEN_KEEPALIVE
+PoseChain * posechain_round_w(const PoseChain * pc, int maxdd) {
+  return posechain_round(pc, maxdd);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int32_t posechain_srid_w(const PoseChain * pc) {
+  return posechain_srid(pc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+PoseChain * posechain_set_srid_w(const PoseChain * pc, int32_t srid) {
+  return posechain_set_srid(pc, srid);
+}
+
+EMSCRIPTEN_KEEPALIVE
+PoseChain * posechain_transform_w(const PoseChain * pc, int32_t srid_to) {
+  return posechain_transform(pc, srid_to);
+}
+
+EMSCRIPTEN_KEEPALIVE
+PoseChain * posechain_transform_pipeline_w(const PoseChain * pc, const char * pipeline, int32_t srid_to, int is_forward) {
+  return posechain_transform_pipeline(pc, pipeline, srid_to, (bool) is_forward);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tposechain_from_geopose_w(const char * json) {
+  return tposechain_from_geopose(json);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * tposechain_as_geopose_w(const Temporal * temp, int precision) {
+  return tposechain_as_geopose(temp, precision);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * tposechainarr_as_geopose_w(const Temporal ** temparr, int count, int precision) {
+  return tposechainarr_as_geopose(temparr, count, precision);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int posechain_eq_w(const PoseChain * pc1, const PoseChain * pc2) {
+  return (int) posechain_eq(pc1, pc2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int posechain_ne_w(const PoseChain * pc1, const PoseChain * pc2) {
+  return (int) posechain_ne(pc1, pc2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int posechain_same_w(const PoseChain * pc1, const PoseChain * pc2) {
+  return (int) posechain_same(pc1, pc2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int posechain_nsame_w(const PoseChain * pc1, const PoseChain * pc2) {
+  return (int) posechain_nsame(pc1, pc2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int posechain_cmp_w(const PoseChain * pc1, const PoseChain * pc2) {
+  return posechain_cmp(pc1, pc2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int posechain_lt_w(const PoseChain * pc1, const PoseChain * pc2) {
+  return (int) posechain_lt(pc1, pc2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int posechain_le_w(const PoseChain * pc1, const PoseChain * pc2) {
+  return (int) posechain_le(pc1, pc2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int posechain_gt_w(const PoseChain * pc1, const PoseChain * pc2) {
+  return (int) posechain_gt(pc1, pc2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int posechain_ge_w(const PoseChain * pc1, const PoseChain * pc2) {
+  return (int) posechain_ge(pc1, pc2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * posechainset_in_w(const char * str) {
+  return posechainset_in(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * posechainset_out_w(const Set * s, int maxdd) {
+  return posechainset_out(s, maxdd);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * posechainset_make_w(const PoseChain ** values, int count) {
+  return posechainset_make(values, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * posechain_to_set_w(const PoseChain * pc) {
+  return posechain_to_set(pc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+PoseChain * posechainset_end_value_w(const Set * s) {
+  return posechainset_end_value(s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+PoseChain * posechainset_start_value_w(const Set * s) {
+  return posechainset_start_value(s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+PoseChain * posechainset_value_n_w(const Set * s, int n) {
+  PoseChain * r;
+  if (!posechainset_value_n(s, n, &r)) return NULL;
+  return r;
+}
+
+EMSCRIPTEN_KEEPALIVE
+PoseChain ** posechainset_values_w(const Set * s, int * count) {
+  return posechainset_values(s, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int contained_posechain_set_w(const PoseChain * pc, const Set * s) {
+  return (int) contained_posechain_set(pc, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int contains_set_posechain_w(const Set * s, PoseChain * pc) {
+  return (int) contains_set_posechain(s, pc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * intersection_posechain_set_w(const PoseChain * pc, const Set * s) {
+  return intersection_posechain_set(pc, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * intersection_set_posechain_w(const Set * s, const PoseChain * pc) {
+  return intersection_set_posechain(s, pc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * minus_posechain_set_w(const PoseChain * pc, const Set * s) {
+  return minus_posechain_set(pc, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * minus_set_posechain_w(const Set * s, const PoseChain * pc) {
+  return minus_set_posechain(s, pc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * posechain_union_transfn_w(Set * state, const PoseChain * pc) {
+  return posechain_union_transfn(state, pc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * union_posechain_set_w(const PoseChain * pc, const Set * s) {
+  return union_posechain_set(pc, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * union_set_posechain_w(const Set * s, const PoseChain * pc) {
+  return union_set_posechain(s, pc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tposechain_in_w(const char * str) {
+  return tposechain_in(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tposechain_from_mfjson_w(const char * mfjson) {
+  return tposechain_from_mfjson(mfjson);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tposechain_from_base_temp_w(const PoseChain * pc, const Temporal * temp) {
+  return tposechain_from_base_temp(pc, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tposechain_to_tpose_w(const Temporal * temp) {
+  return tposechain_to_tpose(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int tposechain_num_poses_w(const Temporal * temp) {
+  return tposechain_num_poses(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_eq_posechain_tposechain_w(const PoseChain * posechain, const Temporal * temp) {
+  return always_eq_posechain_tposechain(posechain, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_eq_tposechain_posechain_w(const Temporal * temp, const PoseChain * posechain) {
+  return always_eq_tposechain_posechain(temp, posechain);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_eq_tposechain_tposechain_w(const Temporal * temp1, const Temporal * temp2) {
+  return always_eq_tposechain_tposechain(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_ne_posechain_tposechain_w(const PoseChain * posechain, const Temporal * temp) {
+  return always_ne_posechain_tposechain(posechain, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_ne_tposechain_posechain_w(const Temporal * temp, const PoseChain * posechain) {
+  return always_ne_tposechain_posechain(temp, posechain);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_ne_tposechain_tposechain_w(const Temporal * temp1, const Temporal * temp2) {
+  return always_ne_tposechain_tposechain(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_eq_posechain_tposechain_w(const PoseChain * posechain, const Temporal * temp) {
+  return ever_eq_posechain_tposechain(posechain, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_eq_tposechain_posechain_w(const Temporal * temp, const PoseChain * posechain) {
+  return ever_eq_tposechain_posechain(temp, posechain);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_eq_tposechain_tposechain_w(const Temporal * temp1, const Temporal * temp2) {
+  return ever_eq_tposechain_tposechain(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_ne_posechain_tposechain_w(const PoseChain * posechain, const Temporal * temp) {
+  return ever_ne_posechain_tposechain(posechain, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_ne_tposechain_posechain_w(const Temporal * temp, const PoseChain * posechain) {
+  return ever_ne_tposechain_posechain(temp, posechain);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_ne_tposechain_tposechain_w(const Temporal * temp1, const Temporal * temp2) {
+  return ever_ne_tposechain_tposechain(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * teq_posechain_tposechain_w(const PoseChain * posechain, const Temporal * temp) {
+  return teq_posechain_tposechain(posechain, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * teq_tposechain_posechain_w(const Temporal * temp, const PoseChain * posechain) {
+  return teq_tposechain_posechain(temp, posechain);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tne_posechain_tposechain_w(const PoseChain * posechain, const Temporal * temp) {
+  return tne_posechain_tposechain(posechain, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tne_tposechain_posechain_w(const Temporal * temp, const PoseChain * posechain) {
+  return tne_tposechain_posechain(temp, posechain);
+}
+
+
+/* === meos_quadbin.h === */
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t quadbin_in_w(const char * str) {
+  return quadbin_in(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int quadbin_eq_w(uint64_t a, uint64_t b) {
+  return (int) quadbin_eq(a, b);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int quadbin_ne_w(uint64_t a, uint64_t b) {
+  return (int) quadbin_ne(a, b);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int quadbin_lt_w(uint64_t a, uint64_t b) {
+  return (int) quadbin_lt(a, b);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int quadbin_le_w(uint64_t a, uint64_t b) {
+  return (int) quadbin_le(a, b);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int quadbin_gt_w(uint64_t a, uint64_t b) {
+  return (int) quadbin_gt(a, b);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int quadbin_ge_w(uint64_t a, uint64_t b) {
+  return (int) quadbin_ge(a, b);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int quadbin_cmp_w(uint64_t a, uint64_t b) {
+  return quadbin_cmp(a, b);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint32_t quadbin_hash_w(uint64_t cell) {
+  return quadbin_hash(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t quadbin_hash_extended_w(uint64_t cell, uint64_t seed) {
+  return quadbin_hash_extended(cell, seed);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int quadbin_is_valid_index_w(uint64_t index) {
+  return (int) quadbin_is_valid_index(index);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int quadbin_is_valid_cell_w(uint64_t cell) {
+  return (int) quadbin_is_valid_cell(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t quadbin_tile_to_cell_w(uint32_t x, uint32_t y, uint32_t z) {
+  return quadbin_tile_to_cell(x, y, z);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int quadbin_cell_to_tile_w(uint64_t cell, uint32_t * x, uint32_t * y, uint32_t * z) {
+  return (int) quadbin_cell_to_tile(cell, x, y, z);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint32_t quadbin_get_resolution_w(uint64_t cell) {
+  return quadbin_get_resolution(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t quadbin_cell_to_parent_w(uint64_t cell, uint32_t parent_resolution) {
+  return quadbin_cell_to_parent(cell, parent_resolution);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t * quadbin_cell_to_children_w(uint64_t cell, uint32_t children_resolution, int * count) {
+  return quadbin_cell_to_children(cell, children_resolution, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t quadbin_cell_sibling_w(uint64_t cell, const char * direction) {
+  return quadbin_cell_sibling(cell, direction);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t * quadbin_k_ring_w(uint64_t cell, int k, int * count) {
+  return quadbin_k_ring(cell, k, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t quadbin_point_to_cell_w(double longitude, double latitude, uint32_t resolution) {
+  return quadbin_point_to_cell(longitude, latitude, resolution);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t geo_to_quadbin_cell_w(const GSERIALIZED * point, int32 resolution) {
+  return geo_to_quadbin_cell(point, resolution);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * quadbin_cell_to_geompoint_w(uint64_t cell) {
+  return quadbin_cell_to_geompoint(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * quadbin_cell_to_geom_w(uint64_t cell) {
+  return quadbin_cell_to_geom(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * quadbin_to_stbox_w(uint64_t cell) {
+  return quadbin_to_stbox(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * quadbin_timestamptz_to_stbox_w(uint64_t cell, long long t) {
+  return quadbin_timestamptz_to_stbox(cell, (TimestampTz) t);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * quadbin_tstzspan_to_stbox_w(uint64_t cell, const Span * s) {
+  return quadbin_tstzspan_to_stbox(cell, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double quadbin_cell_area_w(uint64_t cell) {
+  return quadbin_cell_area(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * quadbin_index_to_string_w(uint64_t index) {
+  return quadbin_index_to_string(index);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t quadbin_string_to_index_w(const char * str) {
+  return quadbin_string_to_index(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * quadbin_cell_to_quadkey_w(uint64_t cell) {
+  return quadbin_cell_to_quadkey(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * quadbin_grid_disk_w(uint64_t origin, int k) {
+  return quadbin_grid_disk(origin, k);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * quadbin_cell_to_children_set_w(uint64_t origin, int children_resolution) {
+  return quadbin_cell_to_children_set(origin, children_resolution);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tquadbin_in_w(const char * str) {
+  return tquadbin_in(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tquadbin_make_w(uint64_t value, long long t) {
+  return tquadbin_make(value, (TimestampTz) t);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TInstant * tquadbininst_make_w(uint64_t value, long long t) {
+  return tquadbininst_make(value, (TimestampTz) t);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequence * tquadbinseq_make_w(const uint64_t * values, const TimestampTz * times, int count, int lower_inc, int upper_inc) {
+  return tquadbinseq_make(values, times, count, (bool) lower_inc, (bool) upper_inc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequenceSet * tquadbinseqset_make_w(const TSequence ** sequences, int count) {
+  return tquadbinseqset_make(sequences, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t tquadbin_start_value_w(const Temporal * temp) {
+  return tquadbin_start_value(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t tquadbin_end_value_w(const Temporal * temp) {
+  return tquadbin_end_value(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+long long tquadbin_value_n_w(const Temporal * temp, int n) {
+  uint64_t r;
+  if (!tquadbin_value_n(temp, n, &r)) return 0;
+  return (long long) r;
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t * tquadbin_values_w(const Temporal * temp, int * count) {
+  return tquadbin_values(temp, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+long long tquadbin_value_at_timestamptz_w(const Temporal * temp, long long t, int strict) {
+  uint64_t r;
+  if (!tquadbin_value_at_timestamptz(temp, (TimestampTz) t, (bool) strict, &r)) return 0;
+  return (long long) r;
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * quadbin_to_set_w(uint64_t cell) {
+  return quadbin_to_set(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tbigint_to_tquadbin_w(const Temporal * temp) {
+  return tbigint_to_tquadbin(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tquadbin_to_tbigint_w(const Temporal * temp) {
+  return tquadbin_to_tbigint(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_eq_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) {
+  return ever_eq_quadbin_tquadbin(cell, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_eq_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) {
+  return ever_eq_tquadbin_quadbin(temp, cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_ne_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) {
+  return ever_ne_quadbin_tquadbin(cell, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_ne_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) {
+  return ever_ne_tquadbin_quadbin(temp, cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_eq_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) {
+  return always_eq_quadbin_tquadbin(cell, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_eq_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) {
+  return always_eq_tquadbin_quadbin(temp, cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_ne_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) {
+  return always_ne_quadbin_tquadbin(cell, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_ne_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) {
+  return always_ne_tquadbin_quadbin(temp, cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_eq_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) {
+  return ever_eq_tquadbin_tquadbin(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_ne_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) {
+  return ever_ne_tquadbin_tquadbin(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_eq_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) {
+  return always_eq_tquadbin_tquadbin(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_ne_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) {
+  return always_ne_tquadbin_tquadbin(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * teq_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) {
+  return teq_quadbin_tquadbin(cell, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * teq_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) {
+  return teq_tquadbin_quadbin(temp, cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * teq_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) {
+  return teq_tquadbin_tquadbin(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tne_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) {
+  return tne_quadbin_tquadbin(cell, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tne_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) {
+  return tne_tquadbin_quadbin(temp, cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tne_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) {
+  return tne_tquadbin_tquadbin(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tquadbin_cell_to_quadkey_w(const Temporal * temp) {
+  return tquadbin_cell_to_quadkey(temp);
+}
+
+
+/* === meos_raster.h === */
+
+EMSCRIPTEN_KEEPALIVE
+size_t raquet_pixtype_size_w(MeosPixType pixtype) {
+  return raquet_pixtype_size(pixtype);
+}
+
+EMSCRIPTEN_KEEPALIVE
+MeosPixType raquet_pixtype_from_string_w(const char * str) {
+  return raquet_pixtype_from_string(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Raquet * raquet_in_w(const char * str) {
+  return raquet_in(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * raquet_out_w(const Raquet * rq) {
+  return raquet_out(rq);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Raquet * raquet_from_wkb_w(const uint8_t * wkb, size_t size) {
+  return raquet_from_wkb(wkb, size);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Raquet * raquet_from_hexwkb_w(const char * hexwkb) {
+  return raquet_from_hexwkb(hexwkb);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint8_t * raquet_as_wkb_w(const Raquet * rq, uint8_t variant, size_t * size_out) {
+  return raquet_as_wkb(rq, variant, size_out);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * raquet_as_hexwkb_w(const Raquet * rq, uint8_t variant, size_t * size_out) {
+  return raquet_as_hexwkb(rq, variant, size_out);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Raquet * raquet_make_w(uint64_t quadbin, int32 width, int32 height, MeosPixType pixtype, double nodata, int has_nodata, const uint8_t * pixels, size_t pixels_size) {
+  return raquet_make(quadbin, width, height, pixtype, nodata, (bool) has_nodata, pixels, pixels_size);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Raquet * raquet_copy_w(const Raquet * rq) {
+  return raquet_copy(rq);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Raquet * raquet_read_w(const char * path, uint64_t quadbin) {
+  return raquet_read(path, quadbin);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Raquet * raquet_read_bytes_w(const uint8_t * data, size_t size, uint64_t quadbin) {
+  return raquet_read_bytes(data, size, quadbin);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t raquet_quadbin_w(const Raquet * rq) {
+  return raquet_quadbin(rq);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int raquet_width_w(const Raquet * rq) {
+  return raquet_width(rq);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int raquet_height_w(const Raquet * rq) {
+  return raquet_height(rq);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double raquet_nodata_w(const Raquet * rq) {
+  return raquet_nodata(rq);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * raquet_pixtype_w(const Raquet * rq) {
+  return raquet_pixtype(rq);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint8_t * raquet_pixels_w(const Raquet * rq, size_t * size_out) {
+  return raquet_pixels(rq, size_out);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint32_t raquet_hash_w(const Raquet * rq) {
+  return raquet_hash(rq);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t raquet_hash_extended_w(const Raquet * rq, uint64_t seed) {
+  return raquet_hash_extended(rq, seed);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Raster * raster_from_wkb_w(const uint8_t * wkb, size_t size) {
+  return raster_from_wkb(wkb, size);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Raster * raster_from_hexwkb_w(const char * hexwkb) {
+  return raster_from_hexwkb(hexwkb);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint8_t * raster_as_wkb_w(const Raster * rast, size_t * size_out) {
+  return raster_as_wkb(rast, size_out);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * raster_as_hexwkb_w(const Raster * rast, size_t * size_out) {
+  return raster_as_hexwkb(rast, size_out);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int raster_num_bands_w(const Raster * rast) {
+  return raster_num_bands(rast);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * raquet_to_stbox_w(const Raquet * rq) {
+  return raquet_to_stbox(rq);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int raquet_cmp_w(const Raquet * rq1, const Raquet * rq2) {
+  return raquet_cmp(rq1, rq2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int raquet_eq_w(const Raquet * rq1, const Raquet * rq2) {
+  return (int) raquet_eq(rq1, rq2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int raquet_ne_w(const Raquet * rq1, const Raquet * rq2) {
+  return (int) raquet_ne(rq1, rq2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int raquet_lt_w(const Raquet * rq1, const Raquet * rq2) {
+  return (int) raquet_lt(rq1, rq2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int raquet_le_w(const Raquet * rq1, const Raquet * rq2) {
+  return (int) raquet_le(rq1, rq2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int raquet_ge_w(const Raquet * rq1, const Raquet * rq2) {
+  return (int) raquet_ge(rq1, rq2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int raquet_gt_w(const Raquet * rq1, const Raquet * rq2) {
+  return (int) raquet_gt(rq1, rq2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * raster_value_w(const Temporal * traj, const STBox * box, raster_sample_fn sample, void * ctx) {
+  return raster_value(traj, box, sample, ctx);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * raster_at_value_w(const Temporal * traj, const STBox * box, raster_sample_fn sample, void * ctx, const Span * vspan) {
+  return raster_at_value(traj, box, sample, ctx, vspan);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * raster_minus_value_w(const Temporal * traj, const STBox * box, raster_sample_fn sample, void * ctx, const Span * vspan) {
+  return raster_minus_value(traj, box, sample, ctx, vspan);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int eraster_value_w(const Temporal * traj, const STBox * box, raster_sample_fn sample, void * ctx, const Span * vspan) {
+  return eraster_value(traj, box, sample, ctx, vspan);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int araster_value_w(const Temporal * traj, const STBox * box, raster_sample_fn sample, void * ctx, const Span * vspan) {
+  return araster_value(traj, box, sample, ctx, vspan);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * raster_value_gdal_w(const Temporal * traj, const char * path, int band) {
+  return raster_value_gdal(traj, path, band);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * raster_at_value_gdal_w(const Temporal * traj, const char * path, int band, const Span * vspan) {
+  return raster_at_value_gdal(traj, path, band, vspan);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * raster_minus_value_gdal_w(const Temporal * traj, const char * path, int band, const Span * vspan) {
+  return raster_minus_value_gdal(traj, path, band, vspan);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int eraster_value_gdal_w(const Temporal * traj, const char * path, int band, const Span * vspan) {
+  return eraster_value_gdal(traj, path, band, vspan);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int araster_value_gdal_w(const Temporal * traj, const char * path, int band, const Span * vspan) {
+  return araster_value_gdal(traj, path, band, vspan);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * raster_tile_value_quadbin_w(const Temporal * traj, const uint8_t * pixels, size_t pixels_size, int32 width, int32 height, uint64_t quadbin, MeosPixType pixtype, double nodata, int has_nodata) {
+  return raster_tile_value_quadbin(traj, pixels, pixels_size, width, height, quadbin, pixtype, nodata, (bool) has_nodata);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * raster_tile_value_w(const Temporal * traj, const Raquet * rq) {
+  return raster_tile_value(traj, rq);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * raster_tile_value_array_w(const Temporal * traj, const Raquet ** rqarr, int count) {
+  return raster_tile_value_array(traj, rqarr, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t * trajectory_quadbins_w(const Temporal * traj, uint32_t zoom, int * count) {
+  return trajectory_quadbins(traj, zoom, count);
+}
+
+
+/* === meos_rgeo.h === */
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_in_w(const char * str) {
+  return trgeometry_in(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_from_mfjson_w(const char * mfjson) {
+  return trgeometry_from_mfjson(mfjson);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * trgeometry_out_w(const Temporal * temp) {
+  return trgeometry_out(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * trgeometry_as_text_w(const Temporal * temp, int maxdd) {
+  return trgeometry_as_text(temp, maxdd);
 }
 
 EMSCRIPTEN_KEEPALIVE
@@ -13817,797 +15551,2429 @@ char * trgeometry_as_ewkt_w(const Temporal * temp, int maxdd) {
 }
 
 EMSCRIPTEN_KEEPALIVE
-TInstant * trgeometryinst_make_w(const GSERIALIZED * geom, const Pose * pose, long long t) {
-  return trgeometryinst_make(geom, pose, (TimestampTz) t);
+TInstant * trgeometryinst_make_w(const GSERIALIZED * geom, const Pose * pose, long long t) {
+  return trgeometryinst_make(geom, pose, (TimestampTz) t);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequence * trgeometryseq_make_w(const GSERIALIZED * geom, TInstant ** instants, int count, int lower_inc, int upper_inc, interpType interp, int normalize) {
+  return trgeometryseq_make(geom, instants, count, (bool) lower_inc, (bool) upper_inc, interp, (bool) normalize);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequenceSet * trgeometryseqset_make_w(const GSERIALIZED * geom, TSequence ** sequences, int count, int normalize) {
+  return trgeometryseqset_make(geom, sequences, count, (bool) normalize);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequenceSet * trgeometryseqset_make_gaps_w(const GSERIALIZED * geom, TInstant ** instants, int count, interpType interp, const Interval * maxt, double maxdist) {
+  return trgeometryseqset_make_gaps(geom, instants, count, interp, maxt, maxdist);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * geometry_tpose_to_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
+  return geometry_tpose_to_trgeometry(gs, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_to_tpose_w(const Temporal * temp) {
+  return trgeometry_to_tpose(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_to_tgeompoint_w(const Temporal * temp) {
+  return trgeometry_to_tgeompoint(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_to_tgeometry_w(const Temporal * temp) {
+  return trgeometry_to_tgeometry(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TInstant * trgeometry_end_instant_w(const Temporal * temp) {
+  return trgeometry_end_instant(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequence * trgeometry_end_sequence_w(const Temporal * temp) {
+  return trgeometry_end_sequence(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * trgeometry_end_value_w(const Temporal * temp) {
+  return trgeometry_end_value(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * trgeometry_geom_w(const Temporal * temp) {
+  return trgeometry_geom(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TInstant * trgeometry_instant_n_w(const Temporal * temp, int n) {
+  return trgeometry_instant_n(temp, n);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TInstant ** trgeometry_instants_w(const Temporal * temp, int * count) {
+  return trgeometry_instants(temp, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * trgeometry_points_w(const Temporal * temp) {
+  return trgeometry_points(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_yaw_w(const Temporal * temp) {
+  return trgeometry_yaw(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_pitch_w(const Temporal * temp) {
+  return trgeometry_pitch(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_roll_w(const Temporal * temp) {
+  return trgeometry_roll(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequence ** trgeometry_segments_w(const Temporal * temp, int * count) {
+  return trgeometry_segments(temp, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequence * trgeometry_sequence_n_w(const Temporal * temp, int i) {
+  return trgeometry_sequence_n(temp, i);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequence ** trgeometry_sequences_w(const Temporal * temp, int * count) {
+  return trgeometry_sequences(temp, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TInstant * trgeometry_start_instant_w(const Temporal * temp) {
+  return trgeometry_start_instant(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequence * trgeometry_start_sequence_w(const Temporal * temp) {
+  return trgeometry_start_sequence(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * trgeometry_start_value_w(const Temporal * temp) {
+  return trgeometry_start_value(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * trgeometry_value_n_w(const Temporal * temp, int n) {
+  GSERIALIZED * r;
+  if (!trgeometry_value_n(temp, n, &r)) return NULL;
+  return r;
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * trgeometry_traversed_area_w(const Temporal * temp, int unary_union) {
+  return trgeometry_traversed_area(temp, (bool) unary_union);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_centroid_w(const Temporal * temp) {
+  return trgeometry_centroid(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * trgeometry_convex_hull_w(const Temporal * temp) {
+  return trgeometry_convex_hull(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_body_point_trajectory_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return trgeometry_body_point_trajectory(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * trgeometry_space_boxes_w(const Temporal * temp, double xsize, double ysize, double zsize, const GSERIALIZED * sorigin, int bitmatrix, int border_inc, int * count) {
+  return trgeometry_space_boxes(temp, xsize, ysize, zsize, sorigin, (bool) bitmatrix, (bool) border_inc, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * trgeometry_space_time_boxes_w(const Temporal * temp, double xsize, double ysize, double zsize, const Interval * duration, const GSERIALIZED * sorigin, long long torigin, int bitmatrix, int border_inc, int * count) {
+  return trgeometry_space_time_boxes(temp, xsize, ysize, zsize, duration, sorigin, (TimestampTz) torigin, (bool) bitmatrix, (bool) border_inc, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * trgeometry_stboxes_w(const Temporal * temp, int * count) {
+  return trgeometry_stboxes(temp, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * trgeometry_split_n_stboxes_w(const Temporal * temp, int box_count, int * count) {
+  return trgeometry_split_n_stboxes(temp, box_count, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * trgeometry_split_each_n_stboxes_w(const Temporal * temp, int elem_count, int * count) {
+  return trgeometry_split_each_n_stboxes(temp, elem_count, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double trgeometry_hausdorff_distance_w(const Temporal * temp1, const Temporal * temp2) {
+  return trgeometry_hausdorff_distance(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double trgeometry_frechet_distance_w(const Temporal * temp1, const Temporal * temp2) {
+  return trgeometry_frechet_distance(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double trgeometry_dyntimewarp_distance_w(const Temporal * temp1, const Temporal * temp2) {
+  return trgeometry_dyntimewarp_distance(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Match * trgeometry_frechet_path_w(const Temporal * temp1, const Temporal * temp2, int * count) {
+  return trgeometry_frechet_path(temp1, temp2, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Match * trgeometry_dyntimewarp_path_w(const Temporal * temp1, const Temporal * temp2, int * count) {
+  return trgeometry_dyntimewarp_path(temp1, temp2, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double trgeometry_length_w(const Temporal * temp) {
+  return trgeometry_length(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_cumulative_length_w(const Temporal * temp) {
+  return trgeometry_cumulative_length(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_angular_speed_w(const Temporal * temp) {
+  return trgeometry_angular_speed(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_speed_w(const Temporal * temp) {
+  return trgeometry_speed(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * trgeometry_twcentroid_w(const Temporal * temp) {
+  return trgeometry_twcentroid(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_append_tinstant_w(Temporal * temp, const TInstant * inst, interpType interp, double maxdist, const Interval * maxt, int expand) {
+  return trgeometry_append_tinstant(temp, inst, interp, maxdist, maxt, (bool) expand);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_append_tsequence_w(Temporal * temp, const TSequence * seq, int expand) {
+  return trgeometry_append_tsequence(temp, seq, (bool) expand);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_delete_timestamptz_w(const Temporal * temp, long long t, int connect) {
+  return trgeometry_delete_timestamptz(temp, (TimestampTz) t, (bool) connect);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_delete_tstzset_w(const Temporal * temp, const Set * s, int connect) {
+  return trgeometry_delete_tstzset(temp, s, (bool) connect);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_delete_tstzspan_w(const Temporal * temp, const Span * s, int connect) {
+  return trgeometry_delete_tstzspan(temp, s, (bool) connect);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_delete_tstzspanset_w(const Temporal * temp, const SpanSet * ss, int connect) {
+  return trgeometry_delete_tstzspanset(temp, ss, (bool) connect);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_merge_w(const Temporal * temp1, const Temporal * temp2) {
+  return trgeometry_merge(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_merge_array_w(Temporal ** temparr, int count) {
+  return trgeometry_merge_array(temparr, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_round_w(const Temporal * temp, int maxdd) {
+  return trgeometry_round(temp, maxdd);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_set_interp_w(const Temporal * temp, interpType interp) {
+  return trgeometry_set_interp(temp, interp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TInstant * trgeometry_as_tinstant_w(const Temporal * temp) {
+  return trgeometry_as_tinstant(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequence * trgeometry_as_tsequence_w(const Temporal * temp, const char * interp_str) {
+  return trgeometry_as_tsequence(temp, interp_str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequenceSet * trgeometry_as_tsequenceset_w(const Temporal * temp, const char * interp_str) {
+  return trgeometry_as_tsequenceset(temp, interp_str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_after_timestamptz_w(const Temporal * temp, long long t, int strict) {
+  return trgeometry_after_timestamptz(temp, (TimestampTz) t, (bool) strict);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_before_timestamptz_w(const Temporal * temp, long long t, int strict) {
+  return trgeometry_before_timestamptz(temp, (TimestampTz) t, (bool) strict);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_at_geom_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return trgeometry_at_geom(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_minus_geom_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return trgeometry_minus_geom(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_at_stbox_w(const Temporal * temp, const STBox * box, int border_inc) {
+  return trgeometry_at_stbox(temp, box, (bool) border_inc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_minus_stbox_w(const Temporal * temp, const STBox * box, int border_inc) {
+  return trgeometry_minus_stbox(temp, box, (bool) border_inc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_at_value_w(const Temporal * temp, const Pose * pose) {
+  return trgeometry_at_value(temp, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_minus_value_w(const Temporal * temp, const Pose * pose) {
+  return trgeometry_minus_value(temp, pose);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_at_values_w(const Temporal * temp, const Set * s) {
+  return trgeometry_at_values(temp, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_minus_values_w(const Temporal * temp, const Set * s) {
+  return trgeometry_minus_values(temp, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_at_timestamptz_w(const Temporal * temp, long long t) {
+  return trgeometry_at_timestamptz(temp, (TimestampTz) t);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_minus_timestamptz_w(const Temporal * temp, long long t) {
+  return trgeometry_minus_timestamptz(temp, (TimestampTz) t);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_at_tstzset_w(const Temporal * temp, const Set * s) {
+  return trgeometry_at_tstzset(temp, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_minus_tstzset_w(const Temporal * temp, const Set * s) {
+  return trgeometry_minus_tstzset(temp, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_at_tstzspan_w(const Temporal * temp, const Span * s) {
+  return trgeometry_at_tstzspan(temp, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_minus_tstzspan_w(const Temporal * temp, const Span * s) {
+  return trgeometry_minus_tstzspan(temp, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_at_tstzspanset_w(const Temporal * temp, const SpanSet * ss) {
+  return trgeometry_at_tstzspanset(temp, ss);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_minus_tstzspanset_w(const Temporal * temp, const SpanSet * ss) {
+  return trgeometry_minus_tstzspanset(temp, ss);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_at_elevation_w(const Temporal * temp, const Span * s) {
+  return trgeometry_at_elevation(temp, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * trgeometry_minus_elevation_w(const Temporal * temp, const Span * s) {
+  return trgeometry_minus_elevation(temp, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tdistance_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return tdistance_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tdistance_trgeometry_tpoint_w(const Temporal * temp1, const Temporal * temp2) {
+  return tdistance_trgeometry_tpoint(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tdistance_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
+  return tdistance_trgeometry_trgeometry(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double nad_stbox_trgeometry_w(const STBox * box, const Temporal * temp) {
+  return nad_stbox_trgeometry(box, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double nad_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return nad_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double nad_trgeometry_stbox_w(const Temporal * temp, const STBox * box) {
+  return nad_trgeometry_stbox(temp, box);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double nad_trgeometry_tpoint_w(const Temporal * temp1, const Temporal * temp2) {
+  return nad_trgeometry_tpoint(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double nad_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
+  return nad_trgeometry_trgeometry(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TInstant * nai_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return nai_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TInstant * nai_trgeometry_tpoint_w(const Temporal * temp1, const Temporal * temp2) {
+  return nai_trgeometry_tpoint(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TInstant * nai_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
+  return nai_trgeometry_trgeometry(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * shortestline_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return shortestline_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * shortestline_trgeometry_tpoint_w(const Temporal * temp1, const Temporal * temp2) {
+  return shortestline_trgeometry_tpoint(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * shortestline_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
+  return shortestline_trgeometry_trgeometry(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_eq_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
+  return always_eq_geo_trgeometry(gs, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_eq_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return always_eq_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_eq_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
+  return always_eq_trgeometry_trgeometry(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_ne_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
+  return always_ne_geo_trgeometry(gs, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_ne_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return always_ne_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_ne_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
+  return always_ne_trgeometry_trgeometry(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_eq_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
+  return ever_eq_geo_trgeometry(gs, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_eq_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return ever_eq_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_eq_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
+  return ever_eq_trgeometry_trgeometry(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_ne_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
+  return ever_ne_geo_trgeometry(gs, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_ne_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return ever_ne_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_ne_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
+  return ever_ne_trgeometry_trgeometry(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * teq_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
+  return teq_geo_trgeometry(gs, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * teq_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return teq_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tne_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
+  return tne_geo_trgeometry(gs, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tne_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return tne_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int econtains_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
+  return econtains_geo_trgeometry(gs, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int acontains_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
+  return acontains_geo_trgeometry(gs, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ecovers_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
+  return ecovers_geo_trgeometry(gs, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int acovers_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
+  return acovers_geo_trgeometry(gs, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ecovers_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return ecovers_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int acovers_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return acovers_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int edisjoint_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return edisjoint_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int adisjoint_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return adisjoint_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int eintersects_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return eintersects_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int aintersects_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return aintersects_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int etouches_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return etouches_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int atouches_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
+  return atouches_trgeometry_geo(temp, gs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int edwithin_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs, double dist) {
+  return edwithin_trgeometry_geo(temp, gs, dist);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int adwithin_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs, double dist) {
+  return adwithin_trgeometry_geo(temp, gs, dist);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int edisjoint_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
+  return edisjoint_trgeometry_trgeometry(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int adisjoint_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
+  return adisjoint_trgeometry_trgeometry(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int eintersects_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
+  return eintersects_trgeometry_trgeometry(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int aintersects_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
+  return aintersects_trgeometry_trgeometry(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int edwithin_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2, double dist) {
+  return edwithin_trgeometry_trgeometry(temp1, temp2, dist);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int adwithin_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2, double dist) {
+  return adwithin_trgeometry_trgeometry(temp1, temp2, dist);
+}
+
+
+/* === meos_s2cell.h === */
+
+EMSCRIPTEN_KEEPALIVE
+S2CellId s2cell_in_w(const char * str) {
+  return s2cell_in(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * s2cell_out_w(S2CellId cell) {
+  return s2cell_out(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int s2cell_eq_w(S2CellId a, S2CellId b) {
+  return (int) s2cell_eq(a, b);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int s2cell_ne_w(S2CellId a, S2CellId b) {
+  return (int) s2cell_ne(a, b);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int s2cell_lt_w(S2CellId a, S2CellId b) {
+  return (int) s2cell_lt(a, b);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int s2cell_le_w(S2CellId a, S2CellId b) {
+  return (int) s2cell_le(a, b);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int s2cell_gt_w(S2CellId a, S2CellId b) {
+  return (int) s2cell_gt(a, b);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int s2cell_ge_w(S2CellId a, S2CellId b) {
+  return (int) s2cell_ge(a, b);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int s2cell_cmp_w(S2CellId a, S2CellId b) {
+  return s2cell_cmp(a, b);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint32_t s2cell_hash_w(S2CellId cell) {
+  return s2cell_hash(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t s2cell_hash_extended_w(S2CellId cell, uint64_t seed) {
+  return s2cell_hash_extended(cell, seed);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int s2cell_is_valid_cell_w(S2CellId cell) {
+  return (int) s2cell_is_valid_cell(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * s2cell_cell_to_token_w(S2CellId cell) {
+  return s2cell_cell_to_token(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+S2CellId s2cell_token_to_cell_w(const char * token) {
+  return s2cell_token_to_cell(token);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint32_t s2cell_get_resolution_w(S2CellId cell) {
+  return s2cell_get_resolution(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint32_t s2cell_get_face_w(S2CellId cell) {
+  return s2cell_get_face(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+S2CellId s2cell_cell_to_parent_w(S2CellId cell, uint32_t level) {
+  return s2cell_cell_to_parent(cell, level);
+}
+
+EMSCRIPTEN_KEEPALIVE
+S2CellId s2cell_cell_to_child_w(S2CellId cell, uint32_t level, uint32_t position) {
+  return s2cell_cell_to_child(cell, level, position);
+}
+
+EMSCRIPTEN_KEEPALIVE
+S2CellId * s2cell_cell_to_children_w(S2CellId cell, uint32_t level, int * count) {
+  return s2cell_cell_to_children(cell, level, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int s2cell_cell_contains_w(S2CellId cell, S2CellId other) {
+  return (int) s2cell_cell_contains(cell, other);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int s2cell_common_ancestor_level_w(S2CellId a, S2CellId b) {
+  return s2cell_common_ancestor_level(a, b);
+}
+
+EMSCRIPTEN_KEEPALIVE
+S2CellId s2cell_range_min_w(S2CellId cell) {
+  return s2cell_range_min(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+S2CellId s2cell_range_max_w(S2CellId cell) {
+  return s2cell_range_max(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+S2CellId * s2cell_edge_neighbors_w(S2CellId cell, int * count) {
+  return s2cell_edge_neighbors(cell, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+S2CellId s2cell_point_to_cell_w(double longitude, double latitude, uint32_t level) {
+  return s2cell_point_to_cell(longitude, latitude, level);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double s2cell_cell_area_w(S2CellId cell) {
+  return s2cell_cell_area(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+double s2cell_edge_length_w(S2CellId cell, uint32_t edge) {
+  return s2cell_edge_length(cell, edge);
+}
+
+EMSCRIPTEN_KEEPALIVE
+S2CellId geo_to_s2cell_cell_w(const GSERIALIZED * point, int32 level) {
+  return geo_to_s2cell_cell(point, level);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * s2cell_cell_to_geogpoint_w(S2CellId cell) {
+  return s2cell_cell_to_geogpoint(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+GSERIALIZED * s2cell_cell_to_geog_w(S2CellId cell) {
+  return s2cell_cell_to_geog(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * s2cell_to_stbox_w(S2CellId cell) {
+  return s2cell_to_stbox(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * s2cell_timestamptz_to_stbox_w(S2CellId cell, long long t) {
+  return s2cell_timestamptz_to_stbox(cell, (TimestampTz) t);
+}
+
+EMSCRIPTEN_KEEPALIVE
+STBox * s2cell_tstzspan_to_stbox_w(S2CellId cell, const Span * s) {
+  return s2cell_tstzspan_to_stbox(cell, s);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * s2cell_edge_neighbors_set_w(S2CellId cell) {
+  return s2cell_edge_neighbors_set(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * s2cell_cell_to_children_set_w(S2CellId cell, int children_level) {
+  return s2cell_cell_to_children_set(cell, children_level);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * ts2cell_in_w(const char * str) {
+  return ts2cell_in(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * ts2cell_make_w(S2CellId value, long long t) {
+  return ts2cell_make(value, (TimestampTz) t);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TInstant * ts2cellinst_make_w(S2CellId value, long long t) {
+  return ts2cellinst_make(value, (TimestampTz) t);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequence * ts2cellseq_make_w(const S2CellId * values, const TimestampTz * times, int count, int lower_inc, int upper_inc) {
+  return ts2cellseq_make(values, times, count, (bool) lower_inc, (bool) upper_inc);
+}
+
+EMSCRIPTEN_KEEPALIVE
+TSequenceSet * ts2cellseqset_make_w(const TSequence ** sequences, int count) {
+  return ts2cellseqset_make(sequences, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+S2CellId ts2cell_start_value_w(const Temporal * temp) {
+  return ts2cell_start_value(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+S2CellId ts2cell_end_value_w(const Temporal * temp) {
+  return ts2cell_end_value(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+S2CellId ts2cell_value_n_w(const Temporal * temp, int n) {
+  S2CellId r;
+  if (!ts2cell_value_n(temp, n, &r)) return 0;
+  return r;
+}
+
+EMSCRIPTEN_KEEPALIVE
+S2CellId * ts2cell_values_w(const Temporal * temp, int * count) {
+  return ts2cell_values(temp, count);
+}
+
+EMSCRIPTEN_KEEPALIVE
+S2CellId ts2cell_value_at_timestamptz_w(const Temporal * temp, long long t, int strict) {
+  S2CellId r;
+  if (!ts2cell_value_at_timestamptz(temp, (TimestampTz) t, (bool) strict, &r)) return 0;
+  return r;
+}
+
+EMSCRIPTEN_KEEPALIVE
+Set * s2cell_to_set_w(S2CellId cell) {
+  return s2cell_to_set(cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tbigint_to_ts2cell_w(const Temporal * temp) {
+  return tbigint_to_ts2cell(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * ts2cell_to_tbigint_w(const Temporal * temp) {
+  return ts2cell_to_tbigint(temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_eq_s2cell_ts2cell_w(S2CellId cell, const Temporal * temp) {
+  return ever_eq_s2cell_ts2cell(cell, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_eq_ts2cell_s2cell_w(const Temporal * temp, S2CellId cell) {
+  return ever_eq_ts2cell_s2cell(temp, cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_ne_s2cell_ts2cell_w(S2CellId cell, const Temporal * temp) {
+  return ever_ne_s2cell_ts2cell(cell, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_ne_ts2cell_s2cell_w(const Temporal * temp, S2CellId cell) {
+  return ever_ne_ts2cell_s2cell(temp, cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_eq_s2cell_ts2cell_w(S2CellId cell, const Temporal * temp) {
+  return always_eq_s2cell_ts2cell(cell, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_eq_ts2cell_s2cell_w(const Temporal * temp, S2CellId cell) {
+  return always_eq_ts2cell_s2cell(temp, cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_ne_s2cell_ts2cell_w(S2CellId cell, const Temporal * temp) {
+  return always_ne_s2cell_ts2cell(cell, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_ne_ts2cell_s2cell_w(const Temporal * temp, S2CellId cell) {
+  return always_ne_ts2cell_s2cell(temp, cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_eq_ts2cell_ts2cell_w(const Temporal * temp1, const Temporal * temp2) {
+  return ever_eq_ts2cell_ts2cell(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ever_ne_ts2cell_ts2cell_w(const Temporal * temp1, const Temporal * temp2) {
+  return ever_ne_ts2cell_ts2cell(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_eq_ts2cell_ts2cell_w(const Temporal * temp1, const Temporal * temp2) {
+  return always_eq_ts2cell_ts2cell(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int always_ne_ts2cell_ts2cell_w(const Temporal * temp1, const Temporal * temp2) {
+  return always_ne_ts2cell_ts2cell(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * teq_s2cell_ts2cell_w(S2CellId cell, const Temporal * temp) {
+  return teq_s2cell_ts2cell(cell, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * teq_ts2cell_s2cell_w(const Temporal * temp, S2CellId cell) {
+  return teq_ts2cell_s2cell(temp, cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * teq_ts2cell_ts2cell_w(const Temporal * temp1, const Temporal * temp2) {
+  return teq_ts2cell_ts2cell(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tne_s2cell_ts2cell_w(S2CellId cell, const Temporal * temp) {
+  return tne_s2cell_ts2cell(cell, temp);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tne_ts2cell_s2cell_w(const Temporal * temp, S2CellId cell) {
+  return tne_ts2cell_s2cell(temp, cell);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * tne_ts2cell_ts2cell_w(const Temporal * temp1, const Temporal * temp2) {
+  return tne_ts2cell_ts2cell(temp1, temp2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Temporal * ts2cell_cell_to_token_w(const Temporal * temp) {
+  return ts2cell_cell_to_token(temp);
+}
+
+
+/* === pg_bool.h === */
+
+EMSCRIPTEN_KEEPALIVE
+int bool_eq_w(int arg1, int arg2) {
+  return (int) bool_eq((bool) arg1, (bool) arg2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int bool_ge_w(int arg1, int arg2) {
+  return (int) bool_ge((bool) arg1, (bool) arg2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int bool_gt_w(int arg1, int arg2) {
+  return (int) bool_gt((bool) arg1, (bool) arg2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint32_t bool_hash_w(int arg) {
+  return bool_hash((bool) arg);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t bool_hash_extended_w(int arg, int64_t seed) {
+  return bool_hash_extended((bool) arg, seed);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int bool_le_w(int arg1, int arg2) {
+  return (int) bool_le((bool) arg1, (bool) arg2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int bool_lt_w(int arg1, int arg2) {
+  return (int) bool_lt((bool) arg1, (bool) arg2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int bool_ne_w(int arg1, int arg2) {
+  return (int) bool_ne((bool) arg1, (bool) arg2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * bool_to_text_w(int b) {
+  text *_t = bool_to_text((bool) b);
+  if (!_t) return NULL;
+  return text_to_cstring(_t);
+}
+
+
+/* === pg_date.h === */
+
+EMSCRIPTEN_KEEPALIVE
+DateADT add_date_int_w(DateADT date, int32 days) {
+  return add_date_int(date, days);
+}
+
+EMSCRIPTEN_KEEPALIVE
+DateADT add_date_interval_w(DateADT date, Interval * interv) {
+  return add_date_interval(date, interv);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int32 cmp_date_timestamp_w(DateADT date, long long ts) {
+  return cmp_date_timestamp(date, (Timestamp) ts);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int cmp_date_date_w(DateADT date1, DateADT date2) {
+  return cmp_date_date(date1, date2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int32 cmp_date_timestamptz_w(DateADT date, long long tstz) {
+  return cmp_date_timestamptz(date, (TimestampTz) tstz);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int32 cmp_timestamp_date_w(long long ts, DateADT date) {
+  return cmp_timestamp_date((Timestamp) ts, date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int32 cmp_timestamptz_date_w(long long tstz, DateADT date) {
+  return cmp_timestamptz_date((TimestampTz) tstz, date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Numeric date_extract_w(DateADT date, const char * units) {
+  return date_extract(date, cstring_to_text(units));
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint32_t date_hash_w(DateADT date) {
+  return date_hash(date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t date_hash_extended_w(DateADT date, int64_t seed) {
+  return date_hash_extended(date, seed);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int date_is_finite_w(DateADT date) {
+  return (int) date_is_finite(date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+DateADT date_larger_w(DateADT date1, DateADT date2) {
+  return date_larger(date1, date2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+DateADT date_make_w(int year, int mon, int mday) {
+  return date_make(year, mon, mday);
+}
+
+EMSCRIPTEN_KEEPALIVE
+DateADT date_smaller_w(DateADT date1, DateADT date2) {
+  return date_smaller(date1, date2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+long long date_time_to_timestamp_w(DateADT date, TimeADT time) {
+  return date_time_to_timestamp(date, time);
+}
+
+EMSCRIPTEN_KEEPALIVE
+long long date_to_timestamp_w(DateADT date) {
+  return date_to_timestamp(date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+long long date_to_timestamptz_w(DateADT date) {
+  return date_to_timestamptz(date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int eq_date_date_w(DateADT date1, DateADT date2) {
+  return (int) eq_date_date(date1, date2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int eq_date_timestamp_w(DateADT date, long long ts) {
+  return (int) eq_date_timestamp(date, (Timestamp) ts);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int eq_date_timestamptz_w(DateADT date, long long tstz) {
+  return (int) eq_date_timestamptz(date, (TimestampTz) tstz);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int eq_timestamp_date_w(long long ts, DateADT date) {
+  return (int) eq_timestamp_date((Timestamp) ts, date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int eq_timestamptz_date_w(long long tstz, DateADT date) {
+  return (int) eq_timestamptz_date((TimestampTz) tstz, date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ge_date_date_w(DateADT date1, DateADT date2) {
+  return (int) ge_date_date(date1, date2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ge_date_timestamp_w(DateADT date, long long ts) {
+  return (int) ge_date_timestamp(date, (Timestamp) ts);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ge_date_timestamptz_w(DateADT date, long long tstz) {
+  return (int) ge_date_timestamptz(date, (TimestampTz) tstz);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ge_timestamp_date_w(long long ts, DateADT date) {
+  return (int) ge_timestamp_date((Timestamp) ts, date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ge_timestamptz_date_w(long long tstz, DateADT date) {
+  return (int) ge_timestamptz_date((TimestampTz) tstz, date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int gt_date_date_w(DateADT date1, DateADT date2) {
+  return (int) gt_date_date(date1, date2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int gt_date_timestamp_w(DateADT date, long long ts) {
+  return (int) gt_date_timestamp(date, (Timestamp) ts);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int gt_date_timestamptz_w(DateADT date, long long tstz) {
+  return (int) gt_date_timestamptz(date, (TimestampTz) tstz);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int gt_timestamp_date_w(long long ts, DateADT date) {
+  return (int) gt_timestamp_date((Timestamp) ts, date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int gt_timestamptz_date_w(long long tstz, DateADT date) {
+  return (int) gt_timestamptz_date((TimestampTz) tstz, date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int le_date_date_w(DateADT date1, DateADT date2) {
+  return (int) le_date_date(date1, date2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int le_date_timestamp_w(DateADT date, long long ts) {
+  return (int) le_date_timestamp(date, (Timestamp) ts);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int le_date_timestamptz_w(DateADT date, long long tstz) {
+  return (int) le_date_timestamptz(date, (TimestampTz) tstz);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int le_timestamp_date_w(long long ts, DateADT date) {
+  return (int) le_timestamp_date((Timestamp) ts, date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int le_timestamptz_date_w(long long tstz, DateADT date) {
+  return (int) le_timestamptz_date((TimestampTz) tstz, date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int lt_date_date_w(DateADT date1, DateADT date2) {
+  return (int) lt_date_date(date1, date2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int lt_date_timestamp_w(DateADT date, long long ts) {
+  return (int) lt_date_timestamp(date, (Timestamp) ts);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int lt_date_timestamptz_w(DateADT date, long long tstz) {
+  return (int) lt_date_timestamptz(date, (TimestampTz) tstz);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int lt_timestamp_date_w(long long ts, DateADT date) {
+  return (int) lt_timestamp_date((Timestamp) ts, date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int lt_timestamptz_date_w(long long tstz, DateADT date) {
+  return (int) lt_timestamptz_date((TimestampTz) tstz, date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int32 minus_date_date_w(DateADT date1, DateADT date2) {
+  return minus_date_date(date1, date2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+DateADT minus_date_int_w(DateADT date, int32 days) {
+  return minus_date_int(date, days);
+}
+
+EMSCRIPTEN_KEEPALIVE
+DateADT minus_date_interval_w(DateADT date, Interval * span) {
+  return minus_date_interval(date, span);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ne_date_date_w(DateADT date1, DateADT date2) {
+  return (int) ne_date_date(date1, date2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ne_date_timestamp_w(DateADT date, long long ts) {
+  return (int) ne_date_timestamp(date, (Timestamp) ts);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ne_date_timestamptz_w(DateADT date, long long tstz) {
+  return (int) ne_date_timestamptz(date, (TimestampTz) tstz);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ne_timestamp_date_w(long long ts, DateADT date) {
+  return (int) ne_timestamp_date((Timestamp) ts, date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ne_timestamptz_date_w(long long tstz, DateADT date) {
+  return (int) ne_timestamptz_date((TimestampTz) tstz, date);
+}
+
+EMSCRIPTEN_KEEPALIVE
+DateADT timestamp_to_date_w(long long ts) {
+  return timestamp_to_date((Timestamp) ts);
+}
+
+EMSCRIPTEN_KEEPALIVE
+DateADT timestamptz_to_date_w(long long tstz) {
+  return timestamptz_to_date((TimestampTz) tstz);
+}
+
+
+/* === pg_float.h === */
+
+EMSCRIPTEN_KEEPALIVE
+float8 add_float8_float8_w(float8 num1, float8 num2) {
+  return add_float8_float8(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+float8 div_float8_float8_w(float8 num1, float8 num2) {
+  return div_float8_float8(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int eq_float8_float8_w(float8 num1, float8 num2) {
+  return (int) eq_float8_float8(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+float8 float8_abs_w(float8 num) {
+  return float8_abs(num);
+}
+
+EMSCRIPTEN_KEEPALIVE
+float8 float8_ceil_w(float8 num) {
+  return float8_ceil(num);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int float8_cmp_w(float8 num1, float8 num2) {
+  return float8_cmp(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+float8 float8_cos_w(float8 num) {
+  return float8_cos(num);
+}
+
+EMSCRIPTEN_KEEPALIVE
+float8 float8_degrees_w(float8 num) {
+  return float8_degrees(num);
+}
+
+EMSCRIPTEN_KEEPALIVE
+float8 float8_exp_w(float8 num) {
+  return float8_exp(num);
+}
+
+EMSCRIPTEN_KEEPALIVE
+float8 float8_floor_w(float8 num) {
+  return float8_floor(num);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint32_t float8_hash_w(float8 num) {
+  return float8_hash(num);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t float8_hash_extended_w(float8 num, uint64_t seed) {
+  return float8_hash_extended(num, seed);
+}
+
+EMSCRIPTEN_KEEPALIVE
+float8 float8_in_w(const char * str) {
+  return float8_in(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+float8 float8_ln_w(float8 num) {
+  return float8_ln(num);
+}
+
+EMSCRIPTEN_KEEPALIVE
+float8 float8_log10_w(float8 num) {
+  return float8_log10(num);
+}
+
+EMSCRIPTEN_KEEPALIVE
+float8 float8_radians_w(float8 num) {
+  return float8_radians(num);
+}
+
+EMSCRIPTEN_KEEPALIVE
+float8 float8_sin_w(float8 num) {
+  return float8_sin(num);
+}
+
+EMSCRIPTEN_KEEPALIVE
+float8 float8_tan_w(float8 num) {
+  return float8_tan(num);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ge_float8_float8_w(float8 num1, float8 num2) {
+  return (int) ge_float8_float8(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int gt_float8_float8_w(float8 num1, float8 num2) {
+  return (int) gt_float8_float8(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int le_float8_float8_w(float8 num1, float8 num2) {
+  return (int) le_float8_float8(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequence * trgeometryseq_make_w(const GSERIALIZED * geom, TInstant ** instants, int count, int lower_inc, int upper_inc, interpType interp, int normalize) {
-  return trgeometryseq_make(geom, instants, count, (bool) lower_inc, (bool) upper_inc, interp, (bool) normalize);
+int lt_float8_float8_w(float8 num1, float8 num2) {
+  return (int) lt_float8_float8(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequenceSet * trgeometryseqset_make_w(const GSERIALIZED * geom, TSequence ** sequences, int count, int normalize) {
-  return trgeometryseqset_make(geom, sequences, count, (bool) normalize);
+float8 minus_float8_float8_w(float8 num1, float8 num2) {
+  return minus_float8_float8(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequenceSet * trgeometryseqset_make_gaps_w(const GSERIALIZED * geom, TInstant ** instants, int count, interpType interp, const Interval * maxt, double maxdist) {
-  return trgeometryseqset_make_gaps(geom, instants, count, interp, maxt, maxdist);
+float8 mul_float8_float8_w(float8 num1, float8 num2) {
+  return mul_float8_float8(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * geometry_tpose_to_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
-  return geometry_tpose_to_trgeometry(gs, temp);
+int ne_float8_float8_w(float8 num1, float8 num2) {
+  return (int) ne_float8_float8(num1, num2);
 }
 
+
+/* === pg_int.h === */
+
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_to_tpose_w(const Temporal * temp) {
-  return trgeometry_to_tpose(temp);
+int32 add_int32_int32_w(int32 num1, int32 num2) {
+  return add_int32_int32(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_to_tgeompoint_w(const Temporal * temp) {
-  return trgeometry_to_tgeompoint(temp);
+int64_t add_int64_int64_w(int64_t num1, int64_t num2) {
+  return add_int64_int64(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_to_tgeometry_w(const Temporal * temp) {
-  return trgeometry_to_tgeometry(temp);
+int32 div_int32_int32_w(int32 num1, int32 num2) {
+  return div_int32_int32(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TInstant * trgeometry_end_instant_w(const Temporal * temp) {
-  return trgeometry_end_instant(temp);
+int64_t div_int64_int64_w(int64_t num1, int64_t num2) {
+  return div_int64_int64(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequence * trgeometry_end_sequence_w(const Temporal * temp) {
-  return trgeometry_end_sequence(temp);
+int eq_int32_int32_w(int32 num1, int32 num2) {
+  return (int) eq_int32_int32(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * trgeometry_end_value_w(const Temporal * temp) {
-  return trgeometry_end_value(temp);
+int eq_int32_int64_w(int32 num1, int64_t num2) {
+  return (int) eq_int32_int64(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * trgeometry_geom_w(const Temporal * temp) {
-  return trgeometry_geom(temp);
+int eq_int64_int32_w(int64_t num1, int32 num2) {
+  return (int) eq_int64_int32(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TInstant * trgeometry_instant_n_w(const Temporal * temp, int n) {
-  return trgeometry_instant_n(temp, n);
+int eq_int64_int64_w(int64_t num1, int64_t num2) {
+  return (int) eq_int64_int64(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TInstant ** trgeometry_instants_w(const Temporal * temp, int * count) {
-  return trgeometry_instants(temp, count);
+int ge_int32_int32_w(int32 num1, int32 num2) {
+  return (int) ge_int32_int32(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Set * trgeometry_points_w(const Temporal * temp) {
-  return trgeometry_points(temp);
+int ge_int32_int64_w(int32 num1, int64_t num2) {
+  return (int) ge_int32_int64(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_yaw_w(const Temporal * temp) {
-  return trgeometry_yaw(temp);
+int ge_int64_int32_w(int64_t num1, int32 num2) {
+  return (int) ge_int64_int32(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_pitch_w(const Temporal * temp) {
-  return trgeometry_pitch(temp);
+int ge_int64_int64_w(int64_t num1, int64_t num2) {
+  return (int) ge_int64_int64(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_roll_w(const Temporal * temp) {
-  return trgeometry_roll(temp);
+int gt_int32_int32_w(int32 num1, int32 num2) {
+  return (int) gt_int32_int32(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequence ** trgeometry_segments_w(const Temporal * temp, int * count) {
-  return trgeometry_segments(temp, count);
+int gt_int32_int64_w(int32 num1, int64_t num2) {
+  return (int) gt_int32_int64(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequence * trgeometry_sequence_n_w(const Temporal * temp, int i) {
-  return trgeometry_sequence_n(temp, i);
+int gt_int64_int32_w(int64_t num1, int32 num2) {
+  return (int) gt_int64_int32(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequence ** trgeometry_sequences_w(const Temporal * temp, int * count) {
-  return trgeometry_sequences(temp, count);
+int gt_int64_int64_w(int64_t num1, int64_t num2) {
+  return (int) gt_int64_int64(num1, num2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TInstant * trgeometry_start_instant_w(const Temporal * temp) {
-  return trgeometry_start_instant(temp);
+int32 int32_abs_w(int32 num) {
+  return int32_abs(num);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequence * trgeometry_start_sequence_w(const Temporal * temp) {
-  return trgeometry_start_sequence(temp);
+int int32_cmp_w(int32 l, int32 r) {
+  return int32_cmp(l, r);
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * trgeometry_start_value_w(const Temporal * temp) {
-  return trgeometry_start_value(temp);
+uint32_t int32_hash_w(int32 val) {
+  return int32_hash(val);
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * trgeometry_value_n_w(const Temporal * temp, int n) {
-  GSERIALIZED * r;
-  if (!trgeometry_value_n(temp, n, &r)) return NULL;
-  return r;
+uint64_t int32_hash_extended_w(int32 val, uint64_t seed) {
+  return int32_hash_extended(val, seed);
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * trgeometry_traversed_area_w(const Temporal * temp, int unary_union) {
-  return trgeometry_traversed_area(temp, (bool) unary_union);
+int32 int32_in_w(const char * str) {
+  return int32_in(str);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_centroid_w(const Temporal * temp) {
-  return trgeometry_centroid(temp);
+char * int32_out_w(int32 num) {
+  return int32_out(num);
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * trgeometry_convex_hull_w(const Temporal * temp) {
-  return trgeometry_convex_hull(temp);
+int64_t int64_abs_w(int64_t num) {
+  return int64_abs(num);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_body_point_trajectory_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return trgeometry_body_point_trajectory(temp, gs);
+int int64_cmp_w(int64_t l, int64_t r) {
+  return int64_cmp(l, r);
 }
 
 EMSCRIPTEN_KEEPALIVE
-STBox * trgeometry_space_boxes_w(const Temporal * temp, double xsize, double ysize, double zsize, const GSERIALIZED * sorigin, int bitmatrix, int border_inc, int * count) {
-  return trgeometry_space_boxes(temp, xsize, ysize, zsize, sorigin, (bool) bitmatrix, (bool) border_inc, count);
+uint32_t int64_hash_w(int64_t num) {
+  return int64_hash(num);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t int64_hash_extended_w(int64_t num, uint64_t seed) {
+  return int64_hash_extended(num, seed);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int64_t int64_in_w(const char * str) {
+  return int64_in(str);
+}
+
+EMSCRIPTEN_KEEPALIVE
+char * int64_out_w(int64_t num) {
+  return int64_out(num);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int le_int32_int32_w(int32 num1, int32 num2) {
+  return (int) le_int32_int32(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int le_int32_int64_w(int32 num1, int64_t num2) {
+  return (int) le_int32_int64(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int le_int64_int32_w(int64_t num1, int32 num2) {
+  return (int) le_int64_int32(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int le_int64_int64_w(int64_t num1, int64_t num2) {
+  return (int) le_int64_int64(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int lt_int32_int32_w(int32 num1, int32 num2) {
+  return (int) lt_int32_int32(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int lt_int32_int64_w(int32 num1, int64_t num2) {
+  return (int) lt_int32_int64(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int lt_int64_int32_w(int64_t num1, int32 num2) {
+  return (int) lt_int64_int32(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int lt_int64_int64_w(int64_t num1, int64_t num2) {
+  return (int) lt_int64_int64(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int32 minus_int32_int32_w(int32 num1, int32 num2) {
+  return minus_int32_int32(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int64_t minus_int64_int64_w(int64_t num1, int64_t num2) {
+  return minus_int64_int64(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int32 mul_int32_int32_w(int32 num1, int32 num2) {
+  return mul_int32_int32(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int64_t mul_int64_int64_w(int64_t num1, int64_t num2) {
+  return mul_int64_int64(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ne_int32_int32_w(int32 num1, int32 num2) {
+  return (int) ne_int32_int32(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ne_int32_int64_w(int32 num1, int64_t num2) {
+  return (int) ne_int32_int64(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ne_int64_int32_w(int64_t num1, int32 num2) {
+  return (int) ne_int64_int32(num1, num2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int ne_int64_int64_w(int64_t num1, int64_t num2) {
+  return (int) ne_int64_int64(num1, num2);
+}
+
+
+/* === pg_interval.h === */
+
+EMSCRIPTEN_KEEPALIVE
+Interval * add_interval_interval_w(const Interval * interv1, const Interval * interv2) {
+  return add_interval_interval(interv1, interv2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Interval * div_interval_float8_w(const Interval * interv, float8 factor) {
+  return div_interval_float8(interv, factor);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Interval * interval_copy_w(const Interval * interv) {
+  return interval_copy(interv);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int interval_eq_w(const Interval * interv1, const Interval * interv2) {
+  return (int) interval_eq(interv1, interv2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Numeric interval_extract_w(const Interval * interv, const char * units) {
+  return interval_extract(interv, cstring_to_text(units));
+}
+
+EMSCRIPTEN_KEEPALIVE
+int interval_ge_w(const Interval * interv1, const Interval * interv2) {
+  return (int) interval_ge(interv1, interv2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int interval_gt_w(const Interval * interv1, const Interval * interv2) {
+  return (int) interval_gt(interv1, interv2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint32_t interval_hash_w(const Interval * interv) {
+  return interval_hash(interv);
+}
+
+EMSCRIPTEN_KEEPALIVE
+uint64_t interval_hash_extended_w(const Interval * interv, uint64_t seed) {
+  return interval_hash_extended(interv, seed);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int interval_is_finite_w(const Interval * interv) {
+  return (int) interval_is_finite(interv);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Interval * interval_justify_days_w(const Interval * interv) {
+  return interval_justify_days(interv);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Interval * interval_justify_hours_w(const Interval * interv) {
+  return interval_justify_hours(interv);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Interval * interval_justify_interval_w(const Interval * interv) {
+  return interval_justify_interval(interv);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Interval * interval_larger_w(const Interval * interv1, const Interval * interv2) {
+  return interval_larger(interv1, interv2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int interval_le_w(const Interval * interv1, const Interval * interv2) {
+  return (int) interval_le(interv1, interv2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int interval_lt_w(const Interval * interv1, const Interval * interv2) {
+  return (int) interval_lt(interv1, interv2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Interval * interval_make_w(int32 years, int32 months, int32 weeks, int32 days, int32 hours, int32 mins, float8 secs) {
+  return interval_make(years, months, weeks, days, hours, mins, secs);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int interval_ne_w(const Interval * interv1, const Interval * interv2) {
+  return (int) interval_ne(interv1, interv2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Interval * interval_negate_w(const Interval * interv) {
+  return interval_negate(interv);
+}
+
+EMSCRIPTEN_KEEPALIVE
+float8 interval_part_w(const Interval * interv, const char * units) {
+  return interval_part(interv, cstring_to_text(units));
+}
+
+EMSCRIPTEN_KEEPALIVE
+Interval * interval_scale_w(const Interval * interv, int32 typmod) {
+  return interval_scale(interv, typmod);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Interval * interval_smaller_w(const Interval * interv1, const Interval * interv2) {
+  return interval_smaller(interv1, interv2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Interval * interval_trunc_w(const Interval * interv, const char * units) {
+  return interval_trunc(interv, cstring_to_text(units));
 }
 
 EMSCRIPTEN_KEEPALIVE
-STBox * trgeometry_space_time_boxes_w(const Temporal * temp, double xsize, double ysize, double zsize, const Interval * duration, const GSERIALIZED * sorigin, long long torigin, int bitmatrix, int border_inc, int * count) {
-  return trgeometry_space_time_boxes(temp, xsize, ysize, zsize, duration, sorigin, (TimestampTz) torigin, (bool) bitmatrix, (bool) border_inc, count);
+Interval * minus_interval_interval_w(const Interval * interv1, const Interval * interv2) {
+  return minus_interval_interval(interv1, interv2);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Interval * mul_float8_interval_w(float8 factor, const Interval * interv) {
+  return mul_float8_interval(factor, interv);
+}
+
+EMSCRIPTEN_KEEPALIVE
+Interval * mul_interval_float8_w(const Interval * interv, float8 factor) {
+  return mul_interval_float8(interv, factor);
+}
+
+
+/* === pg_text.h === */
+
+EMSCRIPTEN_KEEPALIVE
+int text_eq_w(const char * txt1, const char * txt2) {
+  return (int) text_eq(cstring_to_text(txt1), cstring_to_text(txt2));
 }
 
 EMSCRIPTEN_KEEPALIVE
-STBox * trgeometry_stboxes_w(const Temporal * temp, int * count) {
-  return trgeometry_stboxes(temp, count);
+int text_ge_w(const char * txt1, const char * txt2) {
+  return (int) text_ge(cstring_to_text(txt1), cstring_to_text(txt2));
 }
 
 EMSCRIPTEN_KEEPALIVE
-STBox * trgeometry_split_n_stboxes_w(const Temporal * temp, int box_count, int * count) {
-  return trgeometry_split_n_stboxes(temp, box_count, count);
+int text_gt_w(const char * txt1, const char * txt2) {
+  return (int) text_gt(cstring_to_text(txt1), cstring_to_text(txt2));
 }
 
 EMSCRIPTEN_KEEPALIVE
-STBox * trgeometry_split_each_n_stboxes_w(const Temporal * temp, int elem_count, int * count) {
-  return trgeometry_split_each_n_stboxes(temp, elem_count, count);
+uint32_t text_hash_w(const char * txt, Oid collid) {
+  return text_hash(cstring_to_text(txt), collid);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double trgeometry_hausdorff_distance_w(const Temporal * temp1, const Temporal * temp2) {
-  return trgeometry_hausdorff_distance(temp1, temp2);
+uint64_t text_hash_extended_w(const char * txt, uint64_t seed, Oid collid) {
+  return text_hash_extended(cstring_to_text(txt), seed, collid);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double trgeometry_frechet_distance_w(const Temporal * temp1, const Temporal * temp2) {
-  return trgeometry_frechet_distance(temp1, temp2);
+int text_le_w(const char * txt1, const char * txt2) {
+  return (int) text_le(cstring_to_text(txt1), cstring_to_text(txt2));
 }
 
 EMSCRIPTEN_KEEPALIVE
-double trgeometry_dyntimewarp_distance_w(const Temporal * temp1, const Temporal * temp2) {
-  return trgeometry_dyntimewarp_distance(temp1, temp2);
+int text_lt_w(const char * txt1, const char * txt2) {
+  return (int) text_lt(cstring_to_text(txt1), cstring_to_text(txt2));
 }
 
 EMSCRIPTEN_KEEPALIVE
-Match * trgeometry_frechet_path_w(const Temporal * temp1, const Temporal * temp2, int * count) {
-  return trgeometry_frechet_path(temp1, temp2, count);
+int text_ne_w(const char * txt1, const char * txt2) {
+  return (int) text_ne(cstring_to_text(txt1), cstring_to_text(txt2));
 }
 
 EMSCRIPTEN_KEEPALIVE
-Match * trgeometry_dyntimewarp_path_w(const Temporal * temp1, const Temporal * temp2, int * count) {
-  return trgeometry_dyntimewarp_path(temp1, temp2, count);
+int text_pattern_ge_w(const char * txt1, const char * txt2) {
+  return (int) text_pattern_ge(cstring_to_text(txt1), cstring_to_text(txt2));
 }
 
 EMSCRIPTEN_KEEPALIVE
-double trgeometry_length_w(const Temporal * temp) {
-  return trgeometry_length(temp);
+int text_pattern_gt_w(const char * txt1, const char * txt2) {
+  return (int) text_pattern_gt(cstring_to_text(txt1), cstring_to_text(txt2));
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_cumulative_length_w(const Temporal * temp) {
-  return trgeometry_cumulative_length(temp);
+int text_pattern_le_w(const char * txt1, const char * txt2) {
+  return (int) text_pattern_le(cstring_to_text(txt1), cstring_to_text(txt2));
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_angular_speed_w(const Temporal * temp) {
-  return trgeometry_angular_speed(temp);
+int text_pattern_lt_w(const char * txt1, const char * txt2) {
+  return (int) text_pattern_lt(cstring_to_text(txt1), cstring_to_text(txt2));
 }
 
+
+/* === pg_time.h === */
+
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_speed_w(const Temporal * temp) {
-  return trgeometry_speed(temp);
+long long date_timetz_to_timestamptz_w(DateADT date, const TimeTzADT * timetz) {
+  return date_timetz_to_timestamptz(date, timetz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * trgeometry_twcentroid_w(const Temporal * temp) {
-  return trgeometry_twcentroid(temp);
+TimeADT interval_to_time_w(const Interval * interv) {
+  return interval_to_time(interv);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_append_tinstant_w(Temporal * temp, const TInstant * inst, interpType interp, double maxdist, const Interval * maxt, int expand) {
-  return trgeometry_append_tinstant(temp, inst, interp, maxdist, maxt, (bool) expand);
+TimeADT minus_time_interval_w(TimeADT time, const Interval * interv) {
+  return minus_time_interval(time, interv);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_append_tsequence_w(Temporal * temp, const TSequence * seq, int expand) {
-  return trgeometry_append_tsequence(temp, seq, (bool) expand);
+Interval * minus_time_time_w(TimeADT time1, TimeADT time2) {
+  return minus_time_time(time1, time2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_delete_timestamptz_w(const Temporal * temp, long long t, int connect) {
-  return trgeometry_delete_timestamptz(temp, (TimestampTz) t, (bool) connect);
+TimeTzADT * minus_timetz_interval_w(const TimeTzADT * timetz, const Interval * interv) {
+  return minus_timetz_interval(timetz, interv);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_delete_tstzset_w(const Temporal * temp, const Set * s, int connect) {
-  return trgeometry_delete_tstzset(temp, s, (bool) connect);
+TimeADT plus_time_interval_w(TimeADT time, Interval * interv) {
+  return plus_time_interval(time, interv);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_delete_tstzspan_w(const Temporal * temp, const Span * s, int connect) {
-  return trgeometry_delete_tstzspan(temp, s, (bool) connect);
+TimeTzADT * plus_timetz_interval_w(const TimeTzADT * timetz, const Interval * interv) {
+  return plus_timetz_interval(timetz, interv);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_delete_tstzspanset_w(const Temporal * temp, const SpanSet * ss, int connect) {
-  return trgeometry_delete_tstzspanset(temp, ss, (bool) connect);
+int time_cmp_w(TimeADT time1, TimeADT time2) {
+  return time_cmp(time1, time2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_merge_w(const Temporal * temp1, const Temporal * temp2) {
-  return trgeometry_merge(temp1, temp2);
+int time_eq_w(TimeADT time1, TimeADT time2) {
+  return (int) time_eq(time1, time2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_merge_array_w(Temporal ** temparr, int count) {
-  return trgeometry_merge_array(temparr, count);
+Numeric time_extract_w(TimeADT time, const char * units) {
+  return time_extract(time, cstring_to_text(units));
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_round_w(const Temporal * temp, int maxdd) {
-  return trgeometry_round(temp, maxdd);
+int time_ge_w(TimeADT time1, TimeADT time2) {
+  return (int) time_ge(time1, time2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_set_interp_w(const Temporal * temp, interpType interp) {
-  return trgeometry_set_interp(temp, interp);
+int time_gt_w(TimeADT time1, TimeADT time2) {
+  return (int) time_gt(time1, time2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TInstant * trgeometry_as_tinstant_w(const Temporal * temp) {
-  return trgeometry_as_tinstant(temp);
+uint32_t time_hash_w(TimeADT time) {
+  return time_hash(time);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequence * trgeometry_as_tsequence_w(const Temporal * temp, const char * interp_str) {
-  return trgeometry_as_tsequence(temp, interp_str);
+uint64_t time_hash_extended_w(TimeADT time, int32 seed) {
+  return time_hash_extended(time, seed);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TSequenceSet * trgeometry_as_tsequenceset_w(const Temporal * temp, const char * interp_str) {
-  return trgeometry_as_tsequenceset(temp, interp_str);
+TimeADT time_larger_w(TimeADT time1, TimeADT time2) {
+  return time_larger(time1, time2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_after_timestamptz_w(const Temporal * temp, long long t, int strict) {
-  return trgeometry_after_timestamptz(temp, (TimestampTz) t, (bool) strict);
+int time_le_w(TimeADT time1, TimeADT time2) {
+  return (int) time_le(time1, time2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_before_timestamptz_w(const Temporal * temp, long long t, int strict) {
-  return trgeometry_before_timestamptz(temp, (TimestampTz) t, (bool) strict);
+int time_lt_w(TimeADT time1, TimeADT time2) {
+  return (int) time_lt(time1, time2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_restrict_values_w(const Temporal * temp, const Set * s, int atfunc) {
-  return trgeometry_restrict_values(temp, s, (bool) atfunc);
+TimeADT time_make_w(int tm_hour, int tm_min, double sec) {
+  return time_make(tm_hour, tm_min, sec);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_restrict_timestamptz_w(const Temporal * temp, long long t, int atfunc) {
-  return trgeometry_restrict_timestamptz(temp, (TimestampTz) t, (bool) atfunc);
+int time_ne_w(TimeADT time1, TimeADT time2) {
+  return (int) time_ne(time1, time2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_restrict_tstzset_w(const Temporal * temp, const Set * s, int atfunc) {
-  return trgeometry_restrict_tstzset(temp, s, (bool) atfunc);
+int time_overlaps_w(TimeADT ts1, TimeADT te1, TimeADT ts2, TimeADT te2) {
+  return (int) time_overlaps(ts1, te1, ts2, te2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_restrict_tstzspan_w(const Temporal * temp, const Span * s, int atfunc) {
-  return trgeometry_restrict_tstzspan(temp, s, (bool) atfunc);
+float8 time_part_w(TimeADT time, const char * units) {
+  return time_part(time, cstring_to_text(units));
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_restrict_tstzspanset_w(const Temporal * temp, const SpanSet * ss, int atfunc) {
-  return trgeometry_restrict_tstzspanset(temp, ss, (bool) atfunc);
+TimeADT time_scale_w(TimeADT date, int32 typmod) {
+  return time_scale(date, typmod);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_at_geom_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return trgeometry_at_geom(temp, gs);
+TimeADT time_smaller_w(TimeADT time1, TimeADT time2) {
+  return time_smaller(time1, time2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_minus_geom_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return trgeometry_minus_geom(temp, gs);
+Interval * time_to_interval_w(TimeADT time) {
+  return time_to_interval(time);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_at_stbox_w(const Temporal * temp, const STBox * box, int border_inc) {
-  return trgeometry_at_stbox(temp, box, (bool) border_inc);
+TimeTzADT * time_to_timetz_w(TimeADT time) {
+  return time_to_timetz(time);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_minus_stbox_w(const Temporal * temp, const STBox * box, int border_inc) {
-  return trgeometry_minus_stbox(temp, box, (bool) border_inc);
+TimeADT timestamp_to_time_w(long long ts) {
+  return timestamp_to_time((Timestamp) ts);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_at_value_w(const Temporal * temp, const Pose * pose) {
-  return trgeometry_at_value(temp, pose);
+TimeADT timestamptz_to_time_w(long long tztz) {
+  return timestamptz_to_time((TimestampTz) tztz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_minus_value_w(const Temporal * temp, const Pose * pose) {
-  return trgeometry_minus_value(temp, pose);
+TimeTzADT * timestamptz_to_timetz_w(long long tztz) {
+  return timestamptz_to_timetz((TimestampTz) tztz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_at_values_w(const Temporal * temp, const Set * s) {
-  return trgeometry_at_values(temp, s);
+TimeTzADT * timetz_at_local_w(const TimeTzADT * timetz) {
+  return timetz_at_local(timetz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_minus_values_w(const Temporal * temp, const Set * s) {
-  return trgeometry_minus_values(temp, s);
+int32 timetz_cmp_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) {
+  return timetz_cmp(timetz1, timetz2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_at_timestamptz_w(const Temporal * temp, long long t) {
-  return trgeometry_at_timestamptz(temp, (TimestampTz) t);
+int timetz_eq_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) {
+  return (int) timetz_eq(timetz1, timetz2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_minus_timestamptz_w(const Temporal * temp, long long t) {
-  return trgeometry_minus_timestamptz(temp, (TimestampTz) t);
+Numeric timetz_extract_w(const TimeTzADT * timetz, const char * units) {
+  return timetz_extract(timetz, cstring_to_text(units));
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_at_tstzset_w(const Temporal * temp, const Set * s) {
-  return trgeometry_at_tstzset(temp, s);
+int timetz_ge_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) {
+  return (int) timetz_ge(timetz1, timetz2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_minus_tstzset_w(const Temporal * temp, const Set * s) {
-  return trgeometry_minus_tstzset(temp, s);
+int timetz_gt_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) {
+  return (int) timetz_gt(timetz1, timetz2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_at_tstzspan_w(const Temporal * temp, const Span * s) {
-  return trgeometry_at_tstzspan(temp, s);
+uint32_t timetz_hash_w(const TimeTzADT * timetz) {
+  return timetz_hash(timetz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_minus_tstzspan_w(const Temporal * temp, const Span * s) {
-  return trgeometry_minus_tstzspan(temp, s);
+uint64_t timetz_hash_extended_w(const TimeTzADT * timetz, int64_t seed) {
+  return timetz_hash_extended(timetz, seed);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_at_tstzspanset_w(const Temporal * temp, const SpanSet * ss) {
-  return trgeometry_at_tstzspanset(temp, ss);
+TimeTzADT * timetz_in_w(const char * str, int32 typmod) {
+  return timetz_in(str, typmod);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_minus_tstzspanset_w(const Temporal * temp, const SpanSet * ss) {
-  return trgeometry_minus_tstzspanset(temp, ss);
+TimeTzADT * timetz_izone_w(const TimeTzADT * timetz, const Interval * zone) {
+  return timetz_izone(timetz, zone);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_at_elevation_w(const Temporal * temp, const Span * s) {
-  return trgeometry_at_elevation(temp, s);
+TimeTzADT * timetz_larger_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) {
+  return timetz_larger(timetz1, timetz2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * trgeometry_minus_elevation_w(const Temporal * temp, const Span * s) {
-  return trgeometry_minus_elevation(temp, s);
+int timetz_le_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) {
+  return (int) timetz_le(timetz1, timetz2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tdistance_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return tdistance_trgeometry_geo(temp, gs);
+int timetz_lt_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) {
+  return (int) timetz_lt(timetz1, timetz2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tdistance_trgeometry_tpoint_w(const Temporal * temp1, const Temporal * temp2) {
-  return tdistance_trgeometry_tpoint(temp1, temp2);
+int timetz_ne_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) {
+  return (int) timetz_ne(timetz1, timetz2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tdistance_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
-  return tdistance_trgeometry_trgeometry(temp1, temp2);
+TimeTzADT * timetz_copy_w(const TimeTzADT * timetz) {
+  return timetz_copy(timetz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double nad_stbox_trgeometry_w(const STBox * box, const Temporal * temp) {
-  return nad_stbox_trgeometry(box, temp);
+char * timetz_out_w(const TimeTzADT * timetz) {
+  return timetz_out(timetz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double nad_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return nad_trgeometry_geo(temp, gs);
+int timetz_overlaps_w(const TimeTzADT * ts1, const TimeTzADT * te1, const TimeTzADT * ts2, const TimeTzADT * te2) {
+  return (int) timetz_overlaps(ts1, te1, ts2, te2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double nad_trgeometry_stbox_w(const Temporal * temp, const STBox * box) {
-  return nad_trgeometry_stbox(temp, box);
+float8 timetz_part_w(const TimeTzADT * timetz, const char * units) {
+  return timetz_part(timetz, cstring_to_text(units));
 }
 
 EMSCRIPTEN_KEEPALIVE
-double nad_trgeometry_tpoint_w(const Temporal * temp1, const Temporal * temp2) {
-  return nad_trgeometry_tpoint(temp1, temp2);
+TimeTzADT * timetz_scale_w(const TimeTzADT * timetz, int32 typmod) {
+  return timetz_scale(timetz, typmod);
 }
 
 EMSCRIPTEN_KEEPALIVE
-double nad_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
-  return nad_trgeometry_trgeometry(temp1, temp2);
+TimeTzADT * timetz_smaller_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) {
+  return timetz_smaller(timetz1, timetz2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TInstant * nai_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return nai_trgeometry_geo(temp, gs);
+TimeADT timetz_to_time_w(const TimeTzADT * timetz) {
+  return timetz_to_time(timetz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-TInstant * nai_trgeometry_tpoint_w(const Temporal * temp1, const Temporal * temp2) {
-  return nai_trgeometry_tpoint(temp1, temp2);
+TimeTzADT * timetz_zone_w(const TimeTzADT * timetz, const char * zone) {
+  return timetz_zone(timetz, cstring_to_text(zone));
 }
 
+
+/* === pg_timestamp.h === */
+
 EMSCRIPTEN_KEEPALIVE
-TInstant * nai_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
-  return nai_trgeometry_trgeometry(temp1, temp2);
+long long add_timestamp_interval_w(long long ts, const Interval * interv) {
+  return add_timestamp_interval((Timestamp) ts, interv);
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * shortestline_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return shortestline_trgeometry_geo(temp, gs);
+long long add_timestamptz_interval_w(long long tstz, const Interval * interv) {
+  return add_timestamptz_interval((TimestampTz) tstz, interv);
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * shortestline_trgeometry_tpoint_w(const Temporal * temp1, const Temporal * temp2) {
-  return shortestline_trgeometry_tpoint(temp1, temp2);
+long long add_timestamptz_interval_at_zone_w(long long tstz, const Interval * interv, const char * zone) {
+  return add_timestamptz_interval_at_zone((TimestampTz) tstz, interv, cstring_to_text(zone));
 }
 
 EMSCRIPTEN_KEEPALIVE
-GSERIALIZED * shortestline_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
-  return shortestline_trgeometry_trgeometry(temp1, temp2);
+int32 cmp_timestamp_timestamp_w(long long ts1, long long ts2) {
+  return cmp_timestamp_timestamp((Timestamp) ts1, (Timestamp) ts2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_eq_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
-  return always_eq_geo_trgeometry(gs, temp);
+int32 cmp_timestamp_timestamptz_w(long long ts, long long tstz) {
+  return cmp_timestamp_timestamptz((Timestamp) ts, (TimestampTz) tstz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_eq_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return always_eq_trgeometry_geo(temp, gs);
+int32 cmp_timestamptz_timestamp_w(long long tstz, long long ts) {
+  return cmp_timestamptz_timestamp((TimestampTz) tstz, (Timestamp) ts);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_eq_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
-  return always_eq_trgeometry_trgeometry(temp1, temp2);
+int eq_timestamp_timestamp_w(long long ts1, long long ts2) {
+  return (int) eq_timestamp_timestamp((Timestamp) ts1, (Timestamp) ts2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_ne_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
-  return always_ne_geo_trgeometry(gs, temp);
+int eq_timestamp_timestamptz_w(long long ts, long long tstz) {
+  return (int) eq_timestamp_timestamptz((Timestamp) ts, (TimestampTz) tstz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_ne_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return always_ne_trgeometry_geo(temp, gs);
+int eq_timestamptz_timestamp_w(long long tstz, long long ts) {
+  return (int) eq_timestamptz_timestamp((TimestampTz) tstz, (Timestamp) ts);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int always_ne_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
-  return always_ne_trgeometry_trgeometry(temp1, temp2);
+int eq_timestamptz_timestamptz_w(long long tstz1, long long tstz2) {
+  return (int) eq_timestamptz_timestamptz((TimestampTz) tstz1, (TimestampTz) tstz2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_eq_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
-  return ever_eq_geo_trgeometry(gs, temp);
+long long float8_to_timestamptz_w(float8 seconds) {
+  return float8_to_timestamptz(seconds);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_eq_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return ever_eq_trgeometry_geo(temp, gs);
+int gt_timestamp_timestamp_w(long long ts1, long long ts2) {
+  return (int) gt_timestamp_timestamp((Timestamp) ts1, (Timestamp) ts2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_eq_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
-  return ever_eq_trgeometry_trgeometry(temp1, temp2);
+int gt_timestamp_timestamptz_w(long long ts, long long tstz) {
+  return (int) gt_timestamp_timestamptz((Timestamp) ts, (TimestampTz) tstz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_ne_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
-  return ever_ne_geo_trgeometry(gs, temp);
+int gt_timestamptz_timestamp_w(long long tstz, long long ts) {
+  return (int) gt_timestamptz_timestamp((TimestampTz) tstz, (Timestamp) ts);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_ne_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return ever_ne_trgeometry_geo(temp, gs);
+int ge_timestamp_timestamp_w(long long ts1, long long ts2) {
+  return (int) ge_timestamp_timestamp((Timestamp) ts1, (Timestamp) ts2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ever_ne_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
-  return ever_ne_trgeometry_trgeometry(temp1, temp2);
+int ge_timestamp_timestamptz_w(long long ts, long long tstz) {
+  return (int) ge_timestamp_timestamptz((Timestamp) ts, (TimestampTz) tstz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * teq_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
-  return teq_geo_trgeometry(gs, temp);
+int ge_timestamptz_timestamp_w(long long tstz, long long ts) {
+  return (int) ge_timestamptz_timestamp((TimestampTz) tstz, (Timestamp) ts);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * teq_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return teq_trgeometry_geo(temp, gs);
+int le_timestamp_timestamp_w(long long ts1, long long ts2) {
+  return (int) le_timestamp_timestamp((Timestamp) ts1, (Timestamp) ts2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tne_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
-  return tne_geo_trgeometry(gs, temp);
+int le_timestamp_timestamptz_w(long long ts, long long tstz) {
+  return (int) le_timestamp_timestamptz((Timestamp) ts, (TimestampTz) tstz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Temporal * tne_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return tne_trgeometry_geo(temp, gs);
+int le_timestamptz_timestamp_w(long long tstz, long long ts) {
+  return (int) le_timestamptz_timestamp((TimestampTz) tstz, (Timestamp) ts);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int econtains_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
-  return econtains_geo_trgeometry(gs, temp);
+int lt_timestamp_timestamp_w(long long ts1, long long ts2) {
+  return (int) lt_timestamp_timestamp((Timestamp) ts1, (Timestamp) ts2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int acontains_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
-  return acontains_geo_trgeometry(gs, temp);
+int lt_timestamp_timestamptz_w(long long ts, long long tstz) {
+  return (int) lt_timestamp_timestamptz((Timestamp) ts, (TimestampTz) tstz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ecovers_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
-  return ecovers_geo_trgeometry(gs, temp);
+int lt_timestamptz_timestamp_w(long long tstz, long long ts) {
+  return (int) lt_timestamptz_timestamp((TimestampTz) tstz, (Timestamp) ts);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int acovers_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) {
-  return acovers_geo_trgeometry(gs, temp);
+long long minus_timestamp_interval_w(long long ts, const Interval * interv) {
+  return minus_timestamp_interval((Timestamp) ts, interv);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int ecovers_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return ecovers_trgeometry_geo(temp, gs);
+Interval * minus_timestamp_timestamp_w(long long ts1, long long ts2) {
+  return minus_timestamp_timestamp((Timestamp) ts1, (Timestamp) ts2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int acovers_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return acovers_trgeometry_geo(temp, gs);
+long long minus_timestamptz_interval_w(long long tstz, const Interval * interv) {
+  return minus_timestamptz_interval((TimestampTz) tstz, interv);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int edisjoint_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return edisjoint_trgeometry_geo(temp, gs);
+long long minus_timestamptz_interval_at_zone_w(long long tstz, const Interval * interv, const char * zone) {
+  return minus_timestamptz_interval_at_zone((TimestampTz) tstz, interv, cstring_to_text(zone));
 }
 
 EMSCRIPTEN_KEEPALIVE
-int adisjoint_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return adisjoint_trgeometry_geo(temp, gs);
+Interval * minus_timestamptz_timestamptz_w(long long tstz1, long long tstz2) {
+  return minus_timestamptz_timestamptz((TimestampTz) tstz1, (TimestampTz) tstz2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int eintersects_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return eintersects_trgeometry_geo(temp, gs);
+int ne_timestamp_timestamp_w(long long ts1, long long ts2) {
+  return (int) ne_timestamp_timestamp((Timestamp) ts1, (Timestamp) ts2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int aintersects_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return aintersects_trgeometry_geo(temp, gs);
+int ne_timestamp_timestamptz_w(long long ts, long long tstz) {
+  return (int) ne_timestamp_timestamptz((Timestamp) ts, (TimestampTz) tstz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int etouches_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return etouches_trgeometry_geo(temp, gs);
+int ne_timestamptz_timestamp_w(long long tstz, long long ts) {
+  return (int) ne_timestamptz_timestamp((TimestampTz) tstz, (Timestamp) ts);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int atouches_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) {
-  return atouches_trgeometry_geo(temp, gs);
+Interval * timestamp_age_w(long long ts1, long long ts2) {
+  return timestamp_age((Timestamp) ts1, (Timestamp) ts2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int edwithin_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs, double dist) {
-  return edwithin_trgeometry_geo(temp, gs, dist);
+long long timestamp_at_local_w(long long ts) {
+  return timestamp_at_local((Timestamp) ts);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int adwithin_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs, double dist) {
-  return adwithin_trgeometry_geo(temp, gs, dist);
+long long timestamp_bin_w(long long ts, const Interval * stride, long long origin) {
+  return timestamp_bin((Timestamp) ts, stride, (Timestamp) origin);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int edisjoint_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
-  return edisjoint_trgeometry_trgeometry(temp1, temp2);
+Numeric timestamp_extract_w(long long ts, const char * units) {
+  return timestamp_extract((Timestamp) ts, cstring_to_text(units));
 }
 
 EMSCRIPTEN_KEEPALIVE
-int adisjoint_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
-  return adisjoint_trgeometry_trgeometry(temp1, temp2);
+uint32_t timestamp_hash_w(long long ts) {
+  return timestamp_hash((Timestamp) ts);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int eintersects_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
-  return eintersects_trgeometry_trgeometry(temp1, temp2);
+uint64_t timestamp_hash_extended_w(long long tstz, uint64_t seed) {
+  return timestamp_hash_extended((TimestampTz) tstz, seed);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int aintersects_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) {
-  return aintersects_trgeometry_trgeometry(temp1, temp2);
+int timestamp_is_finite_w(long long ts) {
+  return (int) timestamp_is_finite((Timestamp) ts);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int edwithin_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2, double dist) {
-  return edwithin_trgeometry_trgeometry(temp1, temp2, dist);
+long long timestamp_izone_w(long long ts, const Interval * zone) {
+  return timestamp_izone((Timestamp) ts, zone);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int adwithin_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2, double dist) {
-  return adwithin_trgeometry_trgeometry(temp1, temp2, dist);
+char * time_of_day_w() {
+  text *_t = time_of_day();
+  if (!_t) return NULL;
+  return text_to_cstring(_t);
 }
 
-
-/* === pg_interval.h === */
-
 EMSCRIPTEN_KEEPALIVE
-Interval * add_interval_interval_w(const Interval * interv1, const Interval * interv2) {
-  return add_interval_interval(interv1, interv2);
+long long timestamp_larger_w(long long ts1, long long ts2) {
+  return timestamp_larger((Timestamp) ts1, (Timestamp) ts2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Interval * div_interval_float8_w(const Interval * interv, float8 factor) {
-  return div_interval_float8(interv, factor);
+long long timestamp_make_w(int32 year, int32 month, int32 mday, int32 hour, int32 min, float8 sec) {
+  return timestamp_make(year, month, mday, hour, min, sec);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Interval * interval_copy_w(const Interval * interv) {
-  return interval_copy(interv);
+int timestamp_overlaps_w(long long ts1, long long te1, long long ts2, long long te2) {
+  return (int) timestamp_overlaps((Timestamp) ts1, (Timestamp) te1, (Timestamp) ts2, (Timestamp) te2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int interval_eq_w(const Interval * interv1, const Interval * interv2) {
-  return (int) interval_eq(interv1, interv2);
+float8 timestamp_part_w(long long ts, const char * units) {
+  return timestamp_part((Timestamp) ts, cstring_to_text(units));
 }
 
 EMSCRIPTEN_KEEPALIVE
-Numeric interval_extract_w(const Interval * interv, const char * units) {
-  return interval_extract(interv, cstring_to_text(units));
+long long timestamp_scale_w(long long ts, int32 typmod) {
+  return timestamp_scale((Timestamp) ts, typmod);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int interval_ge_w(const Interval * interv1, const Interval * interv2) {
-  return (int) interval_ge(interv1, interv2);
+long long timestamp_smaller_w(long long ts1, long long ts2) {
+  return timestamp_smaller((Timestamp) ts1, (Timestamp) ts2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int interval_gt_w(const Interval * interv1, const Interval * interv2) {
-  return (int) interval_gt(interv1, interv2);
+long long timestamp_to_timestamptz_w(long long ts) {
+  return timestamp_to_timestamptz((Timestamp) ts);
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint32_t interval_hash_w(const Interval * interv) {
-  return interval_hash(interv);
+long long timestamp_trunc_w(long long ts, const char * units) {
+  return timestamp_trunc((Timestamp) ts, cstring_to_text(units));
 }
 
 EMSCRIPTEN_KEEPALIVE
-uint64_t interval_hash_extended_w(const Interval * interv, uint64_t seed) {
-  return interval_hash_extended(interv, seed);
+long long timestamp_zone_w(long long ts, const char * zone) {
+  return timestamp_zone((Timestamp) ts, cstring_to_text(zone));
 }
 
 EMSCRIPTEN_KEEPALIVE
-int interval_is_finite_w(const Interval * interv) {
-  return (int) interval_is_finite(interv);
+Interval * timestamptz_age_w(long long tstz1, long long tstz2) {
+  return timestamptz_age((TimestampTz) tstz1, (TimestampTz) tstz2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Interval * interval_justify_days_w(const Interval * interv) {
-  return interval_justify_days(interv);
+long long timestamptz_at_local_w(long long tstz) {
+  return timestamptz_at_local((TimestampTz) tstz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Interval * interval_justify_hours_w(const Interval * interv) {
-  return interval_justify_hours(interv);
+long long timestamptz_bin_w(long long tstz, const Interval * stride, long long origin) {
+  return timestamptz_bin((TimestampTz) tstz, stride, (TimestampTz) origin);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Interval * interval_justify_interval_w(const Interval * interv) {
-  return interval_justify_interval(interv);
+Numeric timestamptz_extract_w(long long tstz, const char * units) {
+  return timestamptz_extract((TimestampTz) tstz, cstring_to_text(units));
 }
 
 EMSCRIPTEN_KEEPALIVE
-Interval * interval_larger_w(const Interval * interv1, const Interval * interv2) {
-  return interval_larger(interv1, interv2);
+int32 timestamptz_hash_w(long long tstz) {
+  return timestamptz_hash((TimestampTz) tstz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int interval_le_w(const Interval * interv1, const Interval * interv2) {
-  return (int) interval_le(interv1, interv2);
+uint64_t timestamptz_hash_extended_w(long long tstz, uint64_t seed) {
+  return timestamptz_hash_extended((TimestampTz) tstz, seed);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int interval_lt_w(const Interval * interv1, const Interval * interv2) {
-  return (int) interval_lt(interv1, interv2);
+long long timestamptz_izone_w(long long tstz, const Interval * zone) {
+  return timestamptz_izone((TimestampTz) tstz, zone);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Interval * interval_make_w(int32 years, int32 months, int32 weeks, int32 days, int32 hours, int32 mins, float8 secs) {
-  return interval_make(years, months, weeks, days, hours, mins, secs);
+long long timestamptz_make_w(int32 year, int32 month, int32 day, int32 hour, int32 min, float8 sec) {
+  return timestamptz_make(year, month, day, hour, min, sec);
 }
 
 EMSCRIPTEN_KEEPALIVE
-int interval_ne_w(const Interval * interv1, const Interval * interv2) {
-  return (int) interval_ne(interv1, interv2);
+long long timestamptz_make_at_timezone_w(int32 year, int32 month, int32 day, int32 hour, int32 min, float8 sec, const char * zone) {
+  return timestamptz_make_at_timezone(year, month, day, hour, min, sec, cstring_to_text(zone));
 }
 
 EMSCRIPTEN_KEEPALIVE
-Interval * interval_negate_w(const Interval * interv) {
-  return interval_negate(interv);
+int timestamptz_overlaps_w(long long ts1, long long te1, long long ts2, long long te2) {
+  return (int) timestamptz_overlaps((TimestampTz) ts1, (TimestampTz) te1, (TimestampTz) ts2, (TimestampTz) te2);
 }
 
 EMSCRIPTEN_KEEPALIVE
-float8 interval_part_w(const Interval * interv, const char * units) {
-  return interval_part(interv, cstring_to_text(units));
+float8 timestamptz_part_w(long long tstz, const char * units) {
+  return timestamptz_part((TimestampTz) tstz, cstring_to_text(units));
 }
 
 EMSCRIPTEN_KEEPALIVE
-Interval * interval_scale_w(const Interval * interv, int32 typmod) {
-  return interval_scale(interv, typmod);
+long long timestamptz_scale_w(long long tstz, int32 typmod) {
+  return timestamptz_scale((TimestampTz) tstz, typmod);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Interval * interval_smaller_w(const Interval * interv1, const Interval * interv2) {
-  return interval_smaller(interv1, interv2);
+long long timestamptz_shift_w(long long tstz, const Interval * interv) {
+  return timestamptz_shift((TimestampTz) tstz, interv);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Interval * interval_trunc_w(const Interval * interv, const char * units) {
-  return interval_trunc(interv, cstring_to_text(units));
+long long timestamptz_to_timestamp_w(long long tstz) {
+  return timestamptz_to_timestamp((TimestampTz) tstz);
 }
 
 EMSCRIPTEN_KEEPALIVE
-Interval * minus_interval_interval_w(const Interval * interv1, const Interval * interv2) {
-  return minus_interval_interval(interv1, interv2);
+long long timestamptz_trunc_w(long long tstz, const char * units) {
+  return timestamptz_trunc((TimestampTz) tstz, cstring_to_text(units));
 }
 
 EMSCRIPTEN_KEEPALIVE
-Interval * mul_float8_interval_w(float8 factor, const Interval * interv) {
-  return mul_float8_interval(factor, interv);
+long long timestamptz_trunc_zone_w(long long tstz, const char * units, const char * zone) {
+  return timestamptz_trunc_zone((TimestampTz) tstz, cstring_to_text(units), cstring_to_text(zone));
 }
 
 EMSCRIPTEN_KEEPALIVE
-Interval * mul_interval_float8_w(const Interval * interv, float8 factor) {
-  return mul_interval_float8(interv, factor);
+long long timestamptz_zone_w(long long tstz, const char * zone) {
+  return timestamptz_zone((TimestampTz) tstz, cstring_to_text(zone));
 }
 
diff --git a/core/functions/functions.generated.ts b/core/functions/functions.generated.ts
index 0d0a627..5f17e08 100644
--- a/core/functions/functions.generated.ts
+++ b/core/functions/functions.generated.ts
@@ -381,12 +381,6 @@ export function text_cmp(txt1: string, txt2: string, collid: number): number {
 	return _r;
 }
 
-export function text_copy(txt: string): string {
-	const _r = call<string>('text_copy_w', 'string', ['string'], [txt]);
-	checkMeosError();
-	return _r;
-}
-
 export function text_initcap(txt: string): string {
 	const _r = call<string>('text_initcap_w', 'string', ['string'], [txt]);
 	checkMeosError();
@@ -520,6 +514,12 @@ export function rtree_create_stbox(): Ptr {
 	return _r;
 }
 
+export function rtree_create_tpcbox(): Ptr {
+	const _r = callPtr('rtree_create_tpcbox_w', [], []);
+	checkMeosError();
+	return _r;
+}
+
 export function rtree_free(rtree: Ptr): void {
 	call<void>('rtree_free_w', null, [ptrArgType()], [ptrArgVal(rtree)]);
 	checkMeosError();
@@ -585,12 +585,6 @@ export function rtree_search_temporal(rtree: Ptr, op: number, temp: Ptr, result:
 	return _r;
 }
 
-export function rtree_search_temporal_dedup(rtree: Ptr, op: number, temp: Ptr, maxboxes: number, result: Ptr): number {
-	const _r = call<number>('rtree_search_temporal_dedup_w', 'number', [ptrArgType(), 'number', ptrArgType(), 'number', ptrArgType()], [ptrArgVal(rtree), op, ptrArgVal(temp), maxboxes, ptrArgVal(result)]);
-	checkMeosError();
-	return _r;
-}
-
 export function rtree_nn_cursor_open(rtree: Ptr, query: Ptr): Ptr {
 	const _r = callPtr('rtree_nn_cursor_open_w', [ptrArgType(), ptrArgType()], [ptrArgVal(rtree), ptrArgVal(query)]);
 	checkMeosError();
@@ -721,12 +715,6 @@ export function sptree_search_temporal(sptree: Ptr, op: number, temp: Ptr, resul
 	return _r;
 }
 
-export function sptree_search_temporal_dedup(sptree: Ptr, op: number, temp: Ptr, maxboxes: number, result: Ptr): number {
-	const _r = call<number>('sptree_search_temporal_dedup_w', 'number', [ptrArgType(), 'number', ptrArgType(), 'number', ptrArgType()], [ptrArgVal(sptree), op, ptrArgVal(temp), maxboxes, ptrArgVal(result)]);
-	checkMeosError();
-	return _r;
-}
-
 export function sptree_nn_cursor_open(sptree: Ptr, query: Ptr): Ptr {
 	const _r = callPtr('sptree_nn_cursor_open_w', [ptrArgType(), ptrArgType()], [ptrArgVal(sptree), ptrArgVal(query)]);
 	checkMeosError();
@@ -764,6 +752,11 @@ export function meos_finalize_collation(): void {
 	checkMeosError();
 }
 
+export function meos_initialize_pointcloud(): void {
+	call<void>('meos_initialize_pointcloud_w', null, [], []);
+	checkMeosError();
+}
+
 export function meos_set_datestyle(newval: string, extra: Ptr): boolean {
 	const _r = call<number>('meos_set_datestyle_w', 'number', ['string', ptrArgType()], [newval, ptrArgVal(extra)]) !== 0;
 	checkMeosError();
@@ -5616,12 +5609,6 @@ export function tbigint_values(temp: Ptr, count: Ptr): Ptr {
 	return _r;
 }
 
-export function tnumber_avg_value(temp: Ptr): number {
-	const _r = call<number>('tnumber_avg_value_w', 'number', [ptrArgType()], [ptrArgVal(temp)]);
-	checkMeosError();
-	return _r;
-}
-
 export function tnumber_integral(temp: Ptr): number {
 	const _r = call<number>('tnumber_integral_w', 'number', [ptrArgType()], [ptrArgVal(temp)]);
 	checkMeosError();
@@ -7338,6 +7325,12 @@ export function overlaps_temporal_temporal(temp1: Ptr, temp2: Ptr): boolean {
 	return _r;
 }
 
+export function temporal_time_overlaps(temp1: Ptr, temp2: Ptr): boolean {
+	const _r = call<number>('temporal_time_overlaps_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
 export function overlaps_temporal_tstzspan(temp: Ptr, s: Ptr): boolean {
 	const _r = call<number>('overlaps_temporal_tstzspan_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]) !== 0;
 	checkMeosError();
@@ -10749,12 +10742,6 @@ export function acontains_tgeo_geo(temp: Ptr, gs: Ptr): number {
 	return _r;
 }
 
-export function acontains_tgeo_tgeo(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('acontains_tgeo_tgeo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
-	checkMeosError();
-	return _r;
-}
-
 export function acovers_geo_tgeo(gs: Ptr, temp: Ptr): number {
 	const _r = call<number>('acovers_geo_tgeo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
 	checkMeosError();
@@ -12174,12 +12161,6 @@ export function atouches_tcbuffer_cbuffer(temp: Ptr, cb: Ptr): number {
 	return _r;
 }
 
-export function atouches_tcbuffer_tcbuffer(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('atouches_tcbuffer_tcbuffer_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
-	checkMeosError();
-	return _r;
-}
-
 export function econtains_cbuffer_tcbuffer(cb: Ptr, temp: Ptr): number {
 	const _r = call<number>('econtains_cbuffer_tcbuffer_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(cb), ptrArgVal(temp)]);
 	checkMeosError();
@@ -12475,6 +12456,45 @@ export function ttouches_tcbuffer_tcbuffer(temp1: Ptr, temp2: Ptr): Ptr {
 }
 
 
+// === meos_cellindex.h ===
+
+export function tcellindex_get_resolution(temp: Ptr): Ptr {
+	const _r = callPtr('tcellindex_get_resolution_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tcellindex_is_valid_cell(temp: Ptr): Ptr {
+	const _r = callPtr('tcellindex_is_valid_cell_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tcellindex_cell_to_parent(temp: Ptr, resolution: number): Ptr {
+	const _r = callPtr('tcellindex_cell_to_parent_w', [ptrArgType(), 'number'], [ptrArgVal(temp), resolution]);
+	checkMeosError();
+	return _r;
+}
+
+export function tcellindex_cell_to_point(temp: Ptr): Ptr {
+	const _r = callPtr('tcellindex_cell_to_point_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tcellindex_cell_to_boundary(temp: Ptr): Ptr {
+	const _r = callPtr('tcellindex_cell_to_boundary_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tcellindex_cell_area(temp: Ptr): Ptr {
+	const _r = callPtr('tcellindex_cell_area_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+
 // === meos_h3.h ===
 
 export function h3index_in(str: string): number {
@@ -13782,24 +13802,6 @@ export function tjsonb_out(temp: Ptr): string {
 	return _r;
 }
 
-export function tjsonbinst_in(str: string): Ptr {
-	const _r = callPtr('tjsonbinst_in_w', ['string'], [str]);
-	checkMeosError();
-	return _r;
-}
-
-export function tjsonbseq_in(str: string, interp: number): Ptr {
-	const _r = callPtr('tjsonbseq_in_w', ['string', 'number'], [str, interp]);
-	checkMeosError();
-	return _r;
-}
-
-export function tjsonbseqset_in(str: string): Ptr {
-	const _r = callPtr('tjsonbseqset_in_w', ['string'], [str]);
-	checkMeosError();
-	return _r;
-}
-
 export function tjsonb_from_base_temp(jsonb: Ptr, temp: Ptr): Ptr {
 	const _r = callPtr('tjsonb_from_base_temp_w', [ptrArgType(), ptrArgType()], [ptrArgVal(jsonb), ptrArgVal(temp)]);
 	checkMeosError();
@@ -14956,2215 +14958,6183 @@ export function tne_tnpoint_npoint(temp: Ptr, np: Ptr): Ptr {
 }
 
 
-// === meos_pose.h ===
+// === meos_pointcloud.h ===
 
-export function pose_as_ewkt(pose: Ptr, maxdd: number): string {
-	const _r = call<string>('pose_as_ewkt_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pose), maxdd]);
+export function pcpoint_hex_in(str: string): Ptr {
+	const _r = callPtr('pcpoint_hex_in_w', ['string'], [str]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_as_hexwkb(pose: Ptr, variant: number, size_out: Ptr): string {
-	const _r = call<string>('pose_as_hexwkb_w', 'string', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(pose), variant, ptrArgVal(size_out)]);
+export function pcpoint_hex_out(pt: Ptr, maxdd: number): string {
+	const _r = call<string>('pcpoint_hex_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pt), maxdd]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_as_text(pose: Ptr, maxdd: number): string {
-	const _r = call<string>('pose_as_text_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pose), maxdd]);
+export function pcpoint_from_hexwkb(hexwkb: string): Ptr {
+	const _r = callPtr('pcpoint_from_hexwkb_w', ['string'], [hexwkb]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_as_wkb(pose: Ptr, variant: number, size_out: Ptr): Ptr {
-	const _r = callPtr('pose_as_wkb_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(pose), variant, ptrArgVal(size_out)]);
+export function pcpoint_as_hexwkb(pt: Ptr): string {
+	const _r = call<string>('pcpoint_as_hexwkb_w', 'string', [ptrArgType()], [ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_from_wkb(wkb: Ptr, size: number): Ptr {
-	const _r = callPtr('pose_from_wkb_w', [ptrArgType(), 'number'], [ptrArgVal(wkb), size]);
+export function pcpoint_make(pcid: number, values: Ptr, count: number): Ptr {
+	const _r = callPtr('pcpoint_make_w', ['number', ptrArgType(), 'number'], [pcid, ptrArgVal(values), count]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_from_hexwkb(hexwkb: string): Ptr {
-	const _r = callPtr('pose_from_hexwkb_w', ['string'], [hexwkb]);
+export function pcpoint_copy(pt: Ptr): Ptr {
+	const _r = callPtr('pcpoint_copy_w', [ptrArgType()], [ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_in(str: string): Ptr {
-	const _r = callPtr('pose_in_w', ['string'], [str]);
+export function pcpoint_get_pcid(pt: Ptr): number {
+	const _r = call<number>('pcpoint_get_pcid_w', 'number', [ptrArgType()], [ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_out(pose: Ptr, maxdd: number): string {
-	const _r = call<string>('pose_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pose), maxdd]);
+export function pcpoint_hash(pt: Ptr): number {
+	const _r = call<number>('pcpoint_hash_w', 'number', [ptrArgType()], [ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_from_geopose(json: string): Ptr {
-	const _r = callPtr('pose_from_geopose_w', ['string'], [json]);
+export function pcpoint_hash_extended(pt: Ptr, seed: number): number {
+	const _r = Number(call<bigint>('pcpoint_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(pt), BigInt(seed)]));
 	checkMeosError();
 	return _r;
 }
 
-export function pose_as_geopose(pose: Ptr, conformance: number, precision: number): string {
-	const _r = call<string>('pose_as_geopose_w', 'string', [ptrArgType(), 'number', 'number'], [ptrArgVal(pose), conformance, precision]);
+export function pcpoint_get_x(pt: Ptr, schema: Ptr, out: Ptr): boolean {
+	const _r = call<number>('pcpoint_get_x_w', 'number', [ptrArgType(), ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(schema), ptrArgVal(out)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_from_geopose(json: string): Ptr {
-	const _r = callPtr('tpose_from_geopose_w', ['string'], [json]);
+export function pcpoint_get_y(pt: Ptr, schema: Ptr, out: Ptr): boolean {
+	const _r = call<number>('pcpoint_get_y_w', 'number', [ptrArgType(), ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(schema), ptrArgVal(out)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_as_geopose(temp: Ptr, conformance: number, precision: number): string {
-	const _r = call<string>('tpose_as_geopose_w', 'string', [ptrArgType(), 'number', 'number'], [ptrArgVal(temp), conformance, precision]);
+export function pcpoint_get_z(pt: Ptr, schema: Ptr, out: Ptr): boolean {
+	const _r = call<number>('pcpoint_get_z_w', 'number', [ptrArgType(), ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(schema), ptrArgVal(out)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_as_geopose_stream_header(temp: Ptr, precision: number): string {
-	const _r = call<string>('tpose_as_geopose_stream_header_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(temp), precision]);
+export function pcpoint_get_dim(pt: Ptr, schema: Ptr, name: string, out: Ptr): boolean {
+	const _r = call<number>('pcpoint_get_dim_w', 'number', [ptrArgType(), ptrArgType(), 'string', ptrArgType()], [ptrArgVal(pt), ptrArgVal(schema), name, ptrArgVal(out)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_as_geopose_stream_element(temp: Ptr, inst: Ptr, precision: number): string {
-	const _r = call<string>('tpose_as_geopose_stream_element_w', 'string', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(inst), precision]);
+export function pcpoint_to_tpcbox(pt: Ptr, schema: Ptr): Ptr {
+	const _r = callPtr('pcpoint_to_tpcbox_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(schema)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_as_geopose_stream(temp: Ptr, precision: number): string {
-	const _r = call<string>('tpose_as_geopose_stream_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(temp), precision]);
+export function meos_pc_schema(pcid: number): Ptr {
+	const _r = callPtr('meos_pc_schema_w', ['number'], [pcid]);
 	checkMeosError();
 	return _r;
 }
 
-export function geopose_frames(count: Ptr): Ptr {
-	const _r = callPtr('geopose_frames_w', [ptrArgType()], [ptrArgVal(count)]);
+export function meos_pc_schema_register(pcid: number, schema: Ptr): void {
+	call<void>('meos_pc_schema_register_w', null, ['number', ptrArgType()], [pcid, ptrArgVal(schema)]);
 	checkMeosError();
-	return _r;
 }
 
-export function geopose_frame(frame_id: number): Ptr {
-	const _r = callPtr('geopose_frame_w', ['number'], [frame_id]);
+export function meos_pc_schema_from_dims(pcid: number, srid: number, compression: string, dims: Ptr, ndims: number): Ptr {
+	const _r = callPtr('meos_pc_schema_from_dims_w', ['number', 'number', 'string', ptrArgType(), 'number'], [pcid, srid, compression, ptrArgVal(dims), ndims]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_apply_geo(pose: Ptr, body: Ptr): Ptr {
-	const _r = callPtr('pose_apply_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(body)]);
+export function meos_pc_schema_register_dims(pcid: number, srid: number, compression: string, dims: Ptr, ndims: number): boolean {
+	const _r = call<number>('meos_pc_schema_register_dims_w', 'number', ['number', 'number', 'string', ptrArgType(), 'number'], [pcid, srid, compression, ptrArgVal(dims), ndims]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_apply_geo(temp: Ptr, body: Ptr): Ptr {
-	const _r = callPtr('tpose_apply_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(body)]);
+export function meos_pc_schema_register_xml(pcid: number, schema: Ptr, xml_text: string): void {
+	call<void>('meos_pc_schema_register_xml_w', null, ['number', ptrArgType(), 'string'], [pcid, ptrArgVal(schema), xml_text]);
 	checkMeosError();
-	return _r;
 }
 
-export function tpose_compose_pose(body: Ptr, frame: Ptr): Ptr {
-	const _r = callPtr('tpose_compose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(body), ptrArgVal(frame)]);
+export function meos_pc_schema_xml(pcid: number): string {
+	const _r = call<string>('meos_pc_schema_xml_w', 'string', ['number'], [pcid]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_compose_tpose(body: Ptr, frame: Ptr): Ptr {
-	const _r = callPtr('pose_compose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(body), ptrArgVal(frame)]);
+export function meos_pc_schema_clear(): void {
+	call<void>('meos_pc_schema_clear_w', null, [], []);
 	checkMeosError();
-	return _r;
 }
 
-export function tpose_compose_tpose(body: Ptr, frame: Ptr): Ptr {
-	const _r = callPtr('tpose_compose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(body), ptrArgVal(frame)]);
+export function meos_pc_schema_srid(pcid: number): number {
+	const _r = call<number>('meos_pc_schema_srid_w', 'number', ['number'], [pcid]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_inverse(temp: Ptr): Ptr {
-	const _r = callPtr('tpose_inverse_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function meos_pc_schema_compression(pcid: number): string {
+	const _r = call<string>('meos_pc_schema_compression_w', 'string', ['number'], [pcid]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_copy(pose: Ptr): Ptr {
-	const _r = callPtr('pose_copy_w', [ptrArgType()], [ptrArgVal(pose)]);
+export function meos_pc_schema_ndims(pcid: number): number {
+	const _r = call<number>('meos_pc_schema_ndims_w', 'number', ['number'], [pcid]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_make_2d(x: number, y: number, theta: number, geodetic: boolean, srid: number): Ptr {
-	const _r = callPtr('pose_make_2d_w', ['number', 'number', 'number', 'number', 'number'], [x, y, theta, geodetic ? 1 : 0, srid]);
+export function meos_set_pointcloud_schemas_xml(path: string): void {
+	call<void>('meos_set_pointcloud_schemas_xml_w', null, ['string'], [path]);
 	checkMeosError();
-	return _r;
 }
 
-export function pose_make_3d(x: number, y: number, z: number, W: number, X: number, Y: number, Z: number, geodetic: boolean, srid: number): Ptr {
-	const _r = callPtr('pose_make_3d_w', ['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number'], [x, y, z, W, X, Y, Z, geodetic ? 1 : 0, srid]);
+export function pcpoint_cmp(pt1: Ptr, pt2: Ptr): number {
+	const _r = call<number>('pcpoint_cmp_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt1), ptrArgVal(pt2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_make_point2d(gs: Ptr, theta: number): Ptr {
-	const _r = callPtr('pose_make_point2d_w', [ptrArgType(), 'number'], [ptrArgVal(gs), theta]);
+export function pcpoint_eq(pt1: Ptr, pt2: Ptr): boolean {
+	const _r = call<number>('pcpoint_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt1), ptrArgVal(pt2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function pose_make_point3d(gs: Ptr, W: number, X: number, Y: number, Z: number): Ptr {
-	const _r = callPtr('pose_make_point3d_w', [ptrArgType(), 'number', 'number', 'number', 'number'], [ptrArgVal(gs), W, X, Y, Z]);
+export function pcpoint_ne(pt1: Ptr, pt2: Ptr): boolean {
+	const _r = call<number>('pcpoint_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt1), ptrArgVal(pt2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function pose_make_point3d_ypr(gs: Ptr, yaw: number, pitch: number, roll: number): Ptr {
-	const _r = callPtr('pose_make_point3d_ypr_w', [ptrArgType(), 'number', 'number', 'number'], [ptrArgVal(gs), yaw, pitch, roll]);
+export function pcpoint_lt(pt1: Ptr, pt2: Ptr): boolean {
+	const _r = call<number>('pcpoint_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt1), ptrArgVal(pt2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function pose_to_point(pose: Ptr): Ptr {
-	const _r = callPtr('pose_to_point_w', [ptrArgType()], [ptrArgVal(pose)]);
+export function pcpoint_le(pt1: Ptr, pt2: Ptr): boolean {
+	const _r = call<number>('pcpoint_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt1), ptrArgVal(pt2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function pose_to_stbox(pose: Ptr): Ptr {
-	const _r = callPtr('pose_to_stbox_w', [ptrArgType()], [ptrArgVal(pose)]);
+export function pcpoint_gt(pt1: Ptr, pt2: Ptr): boolean {
+	const _r = call<number>('pcpoint_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt1), ptrArgVal(pt2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function pose_hash(pose: Ptr): number {
-	const _r = call<number>('pose_hash_w', 'number', [ptrArgType()], [ptrArgVal(pose)]);
+export function pcpoint_ge(pt1: Ptr, pt2: Ptr): boolean {
+	const _r = call<number>('pcpoint_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt1), ptrArgVal(pt2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function pose_hash_extended(pose: Ptr, seed: number): number {
-	const _r = Number(call<bigint>('pose_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(pose), BigInt(seed)]));
+export function pcpatch_hex_in(str: string): Ptr {
+	const _r = callPtr('pcpatch_hex_in_w', ['string'], [str]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_quaternion(pose: Ptr, count: Ptr): Ptr {
-	const _r = callPtr('pose_quaternion_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(count)]);
+export function pcpatch_hex_out(pa: Ptr, maxdd: number): string {
+	const _r = call<string>('pcpatch_hex_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pa), maxdd]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_ypr(pose: Ptr, count: Ptr): Ptr {
-	const _r = callPtr('pose_ypr_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(count)]);
+export function pcpatch_from_hexwkb(hexwkb: string): Ptr {
+	const _r = callPtr('pcpatch_from_hexwkb_w', ['string'], [hexwkb]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_yaw(pose: Ptr): number {
-	const _r = call<number>('pose_yaw_w', 'number', [ptrArgType()], [ptrArgVal(pose)]);
+export function pcpatch_as_hexwkb(pa: Ptr): string {
+	const _r = call<string>('pcpatch_as_hexwkb_w', 'string', [ptrArgType()], [ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_pitch(pose: Ptr): number {
-	const _r = call<number>('pose_pitch_w', 'number', [ptrArgType()], [ptrArgVal(pose)]);
+export function pcpatch_make(points: Ptr, count: number): Ptr {
+	const _r = callPtr('pcpatch_make_w', [ptrArgType(), 'number'], [ptrArgVal(points), count]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_roll(pose: Ptr): number {
-	const _r = call<number>('pose_roll_w', 'number', [ptrArgType()], [ptrArgVal(pose)]);
+export function pcpatch_make_coords(pcid: number, values: Ptr, count: number): Ptr {
+	const _r = callPtr('pcpatch_make_coords_w', ['number', ptrArgType(), 'number'], [pcid, ptrArgVal(values), count]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_angular_distance(pose1: Ptr, pose2: Ptr): number {
-	const _r = call<number>('pose_angular_distance_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]);
+export function pcpatch_copy(pa: Ptr): Ptr {
+	const _r = callPtr('pcpatch_copy_w', [ptrArgType()], [ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_compose(body: Ptr, frame: Ptr): Ptr {
-	const _r = callPtr('pose_compose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(body), ptrArgVal(frame)]);
+export function pcpatch_get_pcid(pa: Ptr): number {
+	const _r = call<number>('pcpatch_get_pcid_w', 'number', [ptrArgType()], [ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_inverse(pose: Ptr): Ptr {
-	const _r = callPtr('pose_inverse_w', [ptrArgType()], [ptrArgVal(pose)]);
+export function pcpatch_npoints(pa: Ptr): number {
+	const _r = call<number>('pcpatch_npoints_w', 'number', [ptrArgType()], [ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_normalize(pose: Ptr): Ptr {
-	const _r = callPtr('pose_normalize_w', [ptrArgType()], [ptrArgVal(pose)]);
+export function pcpatch_hash(pa: Ptr): number {
+	const _r = call<number>('pcpatch_hash_w', 'number', [ptrArgType()], [ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_round(pose: Ptr, maxdd: number): Ptr {
-	const _r = callPtr('pose_round_w', [ptrArgType(), 'number'], [ptrArgVal(pose), maxdd]);
+export function pcpatch_hash_extended(pa: Ptr, seed: number): number {
+	const _r = Number(call<bigint>('pcpatch_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(pa), BigInt(seed)]));
 	checkMeosError();
 	return _r;
 }
 
-export function posearr_round(posearr: Ptr, count: number, maxdd: number): Ptr {
-	const _r = callPtr('posearr_round_w', [ptrArgType(), 'number', 'number'], [ptrArgVal(posearr), count, maxdd]);
+export function pcpatch_to_geom(pa: Ptr): Ptr {
+	const _r = callPtr('pcpatch_to_geom_w', [ptrArgType()], [ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_set_srid(pose: Ptr, srid: number): Ptr {
-	const _r = callPtr('pose_set_srid_w', [ptrArgType(), 'number'], [ptrArgVal(pose), srid]);
+export function pcpatch_cmp(pa1: Ptr, pa2: Ptr): number {
+	const _r = call<number>('pcpatch_cmp_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa1), ptrArgVal(pa2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_srid(pose: Ptr): number {
-	const _r = call<number>('pose_srid_w', 'number', [ptrArgType()], [ptrArgVal(pose)]);
+export function pcpatch_eq(pa1: Ptr, pa2: Ptr): boolean {
+	const _r = call<number>('pcpatch_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa1), ptrArgVal(pa2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function pose_transform(pose: Ptr, srid: number): Ptr {
-	const _r = callPtr('pose_transform_w', [ptrArgType(), 'number'], [ptrArgVal(pose), srid]);
+export function pcpatch_ne(pa1: Ptr, pa2: Ptr): boolean {
+	const _r = call<number>('pcpatch_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa1), ptrArgVal(pa2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function pose_transform_pipeline(pose: Ptr, pipelinestr: string, srid: number, is_forward: boolean): Ptr {
-	const _r = callPtr('pose_transform_pipeline_w', [ptrArgType(), 'string', 'number', 'number'], [ptrArgVal(pose), pipelinestr, srid, is_forward ? 1 : 0]);
+export function pcpatch_lt(pa1: Ptr, pa2: Ptr): boolean {
+	const _r = call<number>('pcpatch_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa1), ptrArgVal(pa2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function pose_tstzspan_to_stbox(pose: Ptr, s: Ptr): Ptr {
-	const _r = callPtr('pose_tstzspan_to_stbox_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]);
+export function pcpatch_le(pa1: Ptr, pa2: Ptr): boolean {
+	const _r = call<number>('pcpatch_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa1), ptrArgVal(pa2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function pose_timestamptz_to_stbox(pose: Ptr, t: TimestampTz): Ptr {
-	const _r = callPtr('pose_timestamptz_to_stbox_w', [ptrArgType(), 'bigint'], [ptrArgVal(pose), BigInt(t)]);
+export function pcpatch_gt(pa1: Ptr, pa2: Ptr): boolean {
+	const _r = call<number>('pcpatch_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa1), ptrArgVal(pa2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function distance_pose_geo(pose: Ptr, gs: Ptr): number {
-	const _r = call<number>('distance_pose_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(gs)]);
+export function pcpatch_ge(pa1: Ptr, pa2: Ptr): boolean {
+	const _r = call<number>('pcpatch_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa1), ptrArgVal(pa2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function distance_pose_pose(pose1: Ptr, pose2: Ptr): number {
-	const _r = call<number>('distance_pose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]);
+export function pcpointset_in(str: string): Ptr {
+	const _r = callPtr('pcpointset_in_w', ['string'], [str]);
 	checkMeosError();
 	return _r;
 }
 
-export function distance_pose_stbox(pose: Ptr, box: Ptr): number {
-	const _r = call<number>('distance_pose_stbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(box)]);
+export function pcpointset_out(s: Ptr, maxdd: number): string {
+	const _r = call<string>('pcpointset_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(s), maxdd]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_cmp(pose1: Ptr, pose2: Ptr): number {
-	const _r = call<number>('pose_cmp_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]);
+export function pcpointset_make(values: Ptr, count: number): Ptr {
+	const _r = callPtr('pcpointset_make_w', [ptrArgType(), 'number'], [ptrArgVal(values), count]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_eq(pose1: Ptr, pose2: Ptr): boolean {
-	const _r = call<number>('pose_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0;
+export function pcpoint_to_set(pt: Ptr): Ptr {
+	const _r = callPtr('pcpoint_to_set_w', [ptrArgType()], [ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_ge(pose1: Ptr, pose2: Ptr): boolean {
-	const _r = call<number>('pose_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0;
+export function pcpointset_start_value(s: Ptr): Ptr {
+	const _r = callPtr('pcpointset_start_value_w', [ptrArgType()], [ptrArgVal(s)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_gt(pose1: Ptr, pose2: Ptr): boolean {
-	const _r = call<number>('pose_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0;
+export function pcpointset_end_value(s: Ptr): Ptr {
+	const _r = callPtr('pcpointset_end_value_w', [ptrArgType()], [ptrArgVal(s)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_le(pose1: Ptr, pose2: Ptr): boolean {
-	const _r = call<number>('pose_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0;
+export function pcpointset_value_n(s: Ptr, n: number): Ptr {
+	const _r = callPtr('pcpointset_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(s), n]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_lt(pose1: Ptr, pose2: Ptr): boolean {
-	const _r = call<number>('pose_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0;
+export function pcpointset_values(s: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('pcpointset_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(count)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_ne(pose1: Ptr, pose2: Ptr): boolean {
-	const _r = call<number>('pose_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0;
+export function contains_set_pcpoint(s: Ptr, pt: Ptr): boolean {
+	const _r = call<number>('contains_set_pcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pt)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function pose_nsame(pose1: Ptr, pose2: Ptr): boolean {
-	const _r = call<number>('pose_nsame_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0;
+export function contained_pcpoint_set(pt: Ptr, s: Ptr): boolean {
+	const _r = call<number>('contained_pcpoint_set_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(s)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function pose_same(pose1: Ptr, pose2: Ptr): boolean {
-	const _r = call<number>('pose_same_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0;
+export function intersection_pcpoint_set(pt: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('intersection_pcpoint_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(s)]);
 	checkMeosError();
 	return _r;
 }
 
-export function poseset_in(str: string): Ptr {
-	const _r = callPtr('poseset_in_w', ['string'], [str]);
+export function intersection_set_pcpoint(s: Ptr, pt: Ptr): Ptr {
+	const _r = callPtr('intersection_set_pcpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function poseset_out(s: Ptr, maxdd: number): string {
-	const _r = call<string>('poseset_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(s), maxdd]);
+export function minus_pcpoint_set(pt: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('minus_pcpoint_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(s)]);
 	checkMeosError();
 	return _r;
 }
 
-export function poseset_make(values: Ptr, count: number): Ptr {
-	const _r = callPtr('poseset_make_w', [ptrArgType(), 'number'], [ptrArgVal(values), count]);
+export function minus_set_pcpoint(s: Ptr, pt: Ptr): Ptr {
+	const _r = callPtr('minus_set_pcpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_to_set(pose: Ptr): Ptr {
-	const _r = callPtr('pose_to_set_w', [ptrArgType()], [ptrArgVal(pose)]);
+export function union_pcpoint_set(pt: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('union_pcpoint_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(s)]);
 	checkMeosError();
 	return _r;
 }
 
-export function poseset_end_value(s: Ptr): Ptr {
-	const _r = callPtr('poseset_end_value_w', [ptrArgType()], [ptrArgVal(s)]);
+export function union_set_pcpoint(s: Ptr, pt: Ptr): Ptr {
+	const _r = callPtr('union_set_pcpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function poseset_start_value(s: Ptr): Ptr {
-	const _r = callPtr('poseset_start_value_w', [ptrArgType()], [ptrArgVal(s)]);
+export function pcpoint_union_transfn(state: Ptr, pt: Ptr): Ptr {
+	const _r = callPtr('pcpoint_union_transfn_w', [ptrArgType(), ptrArgType()], [ptrArgVal(state), ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function poseset_value_n(s: Ptr, n: number): Ptr {
-	const _r = callPtr('poseset_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(s), n]);
+export function pcpatchset_in(str: string): Ptr {
+	const _r = callPtr('pcpatchset_in_w', ['string'], [str]);
 	checkMeosError();
 	return _r;
 }
 
-export function poseset_values(s: Ptr, count: Ptr): Ptr {
-	const _r = callPtr('poseset_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(count)]);
+export function pcpatchset_out(s: Ptr, maxdd: number): string {
+	const _r = call<string>('pcpatchset_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(s), maxdd]);
 	checkMeosError();
 	return _r;
 }
 
-export function contained_pose_set(pose: Ptr, s: Ptr): boolean {
-	const _r = call<number>('contained_pose_set_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]) !== 0;
+export function pcpatchset_make(values: Ptr, count: number): Ptr {
+	const _r = callPtr('pcpatchset_make_w', [ptrArgType(), 'number'], [ptrArgVal(values), count]);
 	checkMeosError();
 	return _r;
 }
 
-export function contains_set_pose(s: Ptr, pose: Ptr): boolean {
-	const _r = call<number>('contains_set_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pose)]) !== 0;
+export function pcpatch_to_set(pa: Ptr): Ptr {
+	const _r = callPtr('pcpatch_to_set_w', [ptrArgType()], [ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function intersection_pose_set(pose: Ptr, s: Ptr): Ptr {
-	const _r = callPtr('intersection_pose_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]);
+export function pcpatchset_start_value(s: Ptr): Ptr {
+	const _r = callPtr('pcpatchset_start_value_w', [ptrArgType()], [ptrArgVal(s)]);
 	checkMeosError();
 	return _r;
 }
 
-export function intersection_set_pose(s: Ptr, pose: Ptr): Ptr {
-	const _r = callPtr('intersection_set_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pose)]);
+export function pcpatchset_end_value(s: Ptr): Ptr {
+	const _r = callPtr('pcpatchset_end_value_w', [ptrArgType()], [ptrArgVal(s)]);
 	checkMeosError();
 	return _r;
 }
 
-export function minus_pose_set(pose: Ptr, s: Ptr): Ptr {
-	const _r = callPtr('minus_pose_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]);
+export function pcpatchset_value_n(s: Ptr, n: number): Ptr {
+	const _r = callPtr('pcpatchset_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(s), n]);
 	checkMeosError();
 	return _r;
 }
 
-export function minus_set_pose(s: Ptr, pose: Ptr): Ptr {
-	const _r = callPtr('minus_set_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pose)]);
+export function pcpatchset_values(s: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('pcpatchset_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(count)]);
 	checkMeosError();
 	return _r;
 }
 
-export function pose_union_transfn(state: Ptr, pose: Ptr): Ptr {
-	const _r = callPtr('pose_union_transfn_w', [ptrArgType(), ptrArgType()], [ptrArgVal(state), ptrArgVal(pose)]);
+export function contains_set_pcpatch(s: Ptr, pa: Ptr): boolean {
+	const _r = call<number>('contains_set_pcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pa)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function union_pose_set(pose: Ptr, s: Ptr): Ptr {
-	const _r = callPtr('union_pose_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]);
+export function contained_pcpatch_set(pa: Ptr, s: Ptr): boolean {
+	const _r = call<number>('contained_pcpatch_set_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(s)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function union_set_pose(s: Ptr, pose: Ptr): Ptr {
-	const _r = callPtr('union_set_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pose)]);
+export function intersection_pcpatch_set(pa: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('intersection_pcpatch_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(s)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_from_mfjson(str: string): Ptr {
-	const _r = callPtr('tpose_from_mfjson_w', ['string'], [str]);
+export function intersection_set_pcpatch(s: Ptr, pa: Ptr): Ptr {
+	const _r = callPtr('intersection_set_pcpatch_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_in(str: string): Ptr {
-	const _r = callPtr('tpose_in_w', ['string'], [str]);
+export function minus_pcpatch_set(pa: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('minus_pcpatch_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(s)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tposeinst_make(pose: Ptr, t: TimestampTz): Ptr {
-	const _r = callPtr('tposeinst_make_w', [ptrArgType(), 'bigint'], [ptrArgVal(pose), BigInt(t)]);
+export function minus_set_pcpatch(s: Ptr, pa: Ptr): Ptr {
+	const _r = callPtr('minus_set_pcpatch_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_from_base_temp(pose: Ptr, temp: Ptr): Ptr {
-	const _r = callPtr('tpose_from_base_temp_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]);
+export function union_pcpatch_set(pa: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('union_pcpatch_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(s)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tposeseq_from_base_tstzset(pose: Ptr, s: Ptr): Ptr {
-	const _r = callPtr('tposeseq_from_base_tstzset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]);
+export function union_set_pcpatch(s: Ptr, pa: Ptr): Ptr {
+	const _r = callPtr('union_set_pcpatch_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tposeseq_from_base_tstzspan(pose: Ptr, s: Ptr, interp: number): Ptr {
-	const _r = callPtr('tposeseq_from_base_tstzspan_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(pose), ptrArgVal(s), interp]);
+export function pcpatch_union_transfn(state: Ptr, pa: Ptr): Ptr {
+	const _r = callPtr('pcpatch_union_transfn_w', [ptrArgType(), ptrArgType()], [ptrArgVal(state), ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tposeseqset_from_base_tstzspanset(pose: Ptr, ss: Ptr, interp: number): Ptr {
-	const _r = callPtr('tposeseqset_from_base_tstzspanset_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(pose), ptrArgVal(ss), interp]);
+export function tpcbox_in(str: string): Ptr {
+	const _r = callPtr('tpcbox_in_w', ['string'], [str]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_make(tpoint: Ptr, ttheta: Ptr): Ptr {
-	const _r = callPtr('tpose_make_w', [ptrArgType(), ptrArgType()], [ptrArgVal(tpoint), ptrArgVal(ttheta)]);
+export function tpcbox_out(box: Ptr, maxdd: number): string {
+	const _r = call<string>('tpcbox_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(box), maxdd]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_to_tpoint(temp: Ptr): Ptr {
-	const _r = callPtr('tpose_to_tpoint_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function tpcbox_make(hasx: boolean, hasz: boolean, hast: boolean, geodetic: boolean, srid: number, pcid: number, xmin: number, xmax: number, ymin: number, ymax: number, zmin: number, zmax: number, period: Ptr): Ptr {
+	const _r = callPtr('tpcbox_make_w', ['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', ptrArgType()], [hasx ? 1 : 0, hasz ? 1 : 0, hast ? 1 : 0, geodetic ? 1 : 0, srid, pcid, xmin, xmax, ymin, ymax, zmin, zmax, ptrArgVal(period)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_end_value(temp: Ptr): Ptr {
-	const _r = callPtr('tpose_end_value_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function tpcbox_copy(box: Ptr): Ptr {
+	const _r = callPtr('tpcbox_copy_w', [ptrArgType()], [ptrArgVal(box)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_points(temp: Ptr): Ptr {
-	const _r = callPtr('tpose_points_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function pcpatch_to_tpcbox(pa: Ptr, srid: number): Ptr {
+	const _r = callPtr('pcpatch_to_tpcbox_w', [ptrArgType(), 'number'], [ptrArgVal(pa), srid]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_yaw(temp: Ptr): Ptr {
-	const _r = callPtr('tpose_yaw_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function tpcbox_hasx(box: Ptr): boolean {
+	const _r = call<number>('tpcbox_hasx_w', 'number', [ptrArgType()], [ptrArgVal(box)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_pitch(temp: Ptr): Ptr {
-	const _r = callPtr('tpose_pitch_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function tpcbox_hasz(box: Ptr): boolean {
+	const _r = call<number>('tpcbox_hasz_w', 'number', [ptrArgType()], [ptrArgVal(box)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_roll(temp: Ptr): Ptr {
-	const _r = callPtr('tpose_roll_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function tpcbox_hast(box: Ptr): boolean {
+	const _r = call<number>('tpcbox_hast_w', 'number', [ptrArgType()], [ptrArgVal(box)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_speed(temp: Ptr): Ptr {
-	const _r = callPtr('tpose_speed_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function tpcbox_geodetic(box: Ptr): boolean {
+	const _r = call<number>('tpcbox_geodetic_w', 'number', [ptrArgType()], [ptrArgVal(box)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_angular_speed(temp: Ptr): Ptr {
-	const _r = callPtr('tpose_angular_speed_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function tpcbox_xmin(box: Ptr): number {
+	const _r = call<number>('tpcbox_xmin_w', 'number', [ptrArgType()], [ptrArgVal(box)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_start_value(temp: Ptr): Ptr {
-	const _r = callPtr('tpose_start_value_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function tpcbox_xmax(box: Ptr): number {
+	const _r = call<number>('tpcbox_xmax_w', 'number', [ptrArgType()], [ptrArgVal(box)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_trajectory(temp: Ptr): Ptr {
-	const _r = callPtr('tpose_trajectory_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function tpcbox_ymin(box: Ptr): number {
+	const _r = call<number>('tpcbox_ymin_w', 'number', [ptrArgType()], [ptrArgVal(box)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_value_at_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): Ptr {
-	const _r = callPtr('tpose_value_at_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0]);
+export function tpcbox_ymax(box: Ptr): number {
+	const _r = call<number>('tpcbox_ymax_w', 'number', [ptrArgType()], [ptrArgVal(box)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_value_n(temp: Ptr, n: number): Ptr {
-	const _r = callPtr('tpose_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), n]);
+export function tpcbox_zmin(box: Ptr): number {
+	const _r = call<number>('tpcbox_zmin_w', 'number', [ptrArgType()], [ptrArgVal(box)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_values(temp: Ptr, count: Ptr): Ptr {
-	const _r = callPtr('tpose_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]);
+export function tpcbox_zmax(box: Ptr): number {
+	const _r = call<number>('tpcbox_zmax_w', 'number', [ptrArgType()], [ptrArgVal(box)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_at_elevation(temp: Ptr, s: Ptr): Ptr {
-	const _r = callPtr('tpose_at_elevation_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+export function tpcbox_tmin(box: Ptr): TimestampTz {
+	const _r = call<TimestampTz>('tpcbox_tmin_w', 'number', [ptrArgType()], [ptrArgVal(box)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_at_geom(temp: Ptr, gs: Ptr): Ptr {
-	const _r = callPtr('tpose_at_geom_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function tpcbox_tmin_inc(box: Ptr): boolean {
+	const _r = call<number>('tpcbox_tmin_inc_w', 'number', [ptrArgType()], [ptrArgVal(box)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_at_stbox(temp: Ptr, box: Ptr, border_inc: boolean): Ptr {
-	const _r = callPtr('tpose_at_stbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(box), border_inc ? 1 : 0]);
+export function tpcbox_tmax(box: Ptr): TimestampTz {
+	const _r = call<TimestampTz>('tpcbox_tmax_w', 'number', [ptrArgType()], [ptrArgVal(box)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_at_pose(temp: Ptr, pose: Ptr): Ptr {
-	const _r = callPtr('tpose_at_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+export function tpcbox_tmax_inc(box: Ptr): boolean {
+	const _r = call<number>('tpcbox_tmax_inc_w', 'number', [ptrArgType()], [ptrArgVal(box)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_minus_elevation(temp: Ptr, s: Ptr): Ptr {
-	const _r = callPtr('tpose_minus_elevation_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+export function tpcbox_srid(box: Ptr): number {
+	const _r = call<number>('tpcbox_srid_w', 'number', [ptrArgType()], [ptrArgVal(box)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_minus_geom(temp: Ptr, gs: Ptr): Ptr {
-	const _r = callPtr('tpose_minus_geom_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function tpcbox_pcid(box: Ptr): number {
+	const _r = call<number>('tpcbox_pcid_w', 'number', [ptrArgType()], [ptrArgVal(box)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_minus_pose(temp: Ptr, pose: Ptr): Ptr {
-	const _r = callPtr('tpose_minus_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+export function tpcbox_to_stbox(box: Ptr): Ptr {
+	const _r = callPtr('tpcbox_to_stbox_w', [ptrArgType()], [ptrArgVal(box)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tpose_minus_stbox(temp: Ptr, box: Ptr, border_inc: boolean): Ptr {
-	const _r = callPtr('tpose_minus_stbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(box), border_inc ? 1 : 0]);
+export function tpcbox_round(box: Ptr, maxdd: number): Ptr {
+	const _r = callPtr('tpcbox_round_w', [ptrArgType(), 'number'], [ptrArgVal(box), maxdd]);
 	checkMeosError();
 	return _r;
 }
 
-export function tdistance_tpose_pose(temp: Ptr, pose: Ptr): Ptr {
-	const _r = callPtr('tdistance_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+export function tpcbox_set_srid(box: Ptr, srid: number): Ptr {
+	const _r = callPtr('tpcbox_set_srid_w', [ptrArgType(), 'number'], [ptrArgVal(box), srid]);
 	checkMeosError();
 	return _r;
 }
 
-export function tdistance_tpose_geo(temp: Ptr, gs: Ptr): Ptr {
-	const _r = callPtr('tdistance_tpose_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function union_tpcbox_tpcbox(box1: Ptr, box2: Ptr, strict: boolean): Ptr {
+	const _r = callPtr('union_tpcbox_tpcbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(box1), ptrArgVal(box2), strict ? 1 : 0]);
 	checkMeosError();
 	return _r;
 }
 
-export function tdistance_tpose_tpose(temp1: Ptr, temp2: Ptr): Ptr {
-	const _r = callPtr('tdistance_tpose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function intersection_tpcbox_tpcbox(box1: Ptr, box2: Ptr): Ptr {
+	const _r = callPtr('intersection_tpcbox_tpcbox_w', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function nad_tpose_geo(temp: Ptr, gs: Ptr): number {
-	const _r = call<number>('nad_tpose_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function contains_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('contains_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function nad_tpose_pose(temp: Ptr, pose: Ptr): number {
-	const _r = call<number>('nad_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+export function contained_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('contained_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function nad_tpose_stbox(temp: Ptr, box: Ptr): number {
-	const _r = call<number>('nad_tpose_stbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]);
+export function overlaps_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('overlaps_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function nad_tpose_tpose(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('nad_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function same_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('same_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function nai_tpose_geo(temp: Ptr, gs: Ptr): Ptr {
-	const _r = callPtr('nai_tpose_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function adjacent_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('adjacent_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function nai_tpose_pose(temp: Ptr, pose: Ptr): Ptr {
-	const _r = callPtr('nai_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+export function tpcbox_cmp(box1: Ptr, box2: Ptr): number {
+	const _r = call<number>('tpcbox_cmp_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function nai_tpose_tpose(temp1: Ptr, temp2: Ptr): Ptr {
-	const _r = callPtr('nai_tpose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function tpcbox_eq(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('tpcbox_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function shortestline_tpose_geo(temp: Ptr, gs: Ptr): Ptr {
-	const _r = callPtr('shortestline_tpose_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function tpcbox_ne(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('tpcbox_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function shortestline_tpose_pose(temp: Ptr, pose: Ptr): Ptr {
-	const _r = callPtr('shortestline_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+export function tpcbox_lt(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('tpcbox_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function shortestline_tpose_tpose(temp1: Ptr, temp2: Ptr): Ptr {
-	const _r = callPtr('shortestline_tpose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function tpcbox_le(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('tpcbox_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function always_eq_pose_tpose(pose: Ptr, temp: Ptr): number {
-	const _r = call<number>('always_eq_pose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]);
+export function tpcbox_gt(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('tpcbox_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function always_eq_tpose_pose(temp: Ptr, pose: Ptr): number {
-	const _r = call<number>('always_eq_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+export function tpcbox_ge(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('tpcbox_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function always_eq_tpose_tpose(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('always_eq_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function left_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('left_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function always_ne_pose_tpose(pose: Ptr, temp: Ptr): number {
-	const _r = call<number>('always_ne_pose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]);
+export function overleft_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('overleft_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function always_ne_tpose_pose(temp: Ptr, pose: Ptr): number {
-	const _r = call<number>('always_ne_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+export function right_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('right_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function always_ne_tpose_tpose(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('always_ne_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function overright_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('overright_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function ever_eq_pose_tpose(pose: Ptr, temp: Ptr): number {
-	const _r = call<number>('ever_eq_pose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]);
+export function below_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('below_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function ever_eq_tpose_pose(temp: Ptr, pose: Ptr): number {
-	const _r = call<number>('ever_eq_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+export function overbelow_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('overbelow_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function ever_eq_tpose_tpose(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('ever_eq_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function above_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('above_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function ever_ne_pose_tpose(pose: Ptr, temp: Ptr): number {
-	const _r = call<number>('ever_ne_pose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]);
+export function overabove_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('overabove_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function ever_ne_tpose_pose(temp: Ptr, pose: Ptr): number {
-	const _r = call<number>('ever_ne_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+export function front_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('front_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function ever_ne_tpose_tpose(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('ever_ne_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function overfront_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('overfront_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function teq_pose_tpose(pose: Ptr, temp: Ptr): Ptr {
-	const _r = callPtr('teq_pose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]);
+export function back_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('back_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function teq_tpose_pose(temp: Ptr, pose: Ptr): Ptr {
-	const _r = callPtr('teq_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+export function overback_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('overback_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tne_pose_tpose(pose: Ptr, temp: Ptr): Ptr {
-	const _r = callPtr('tne_pose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]);
+export function before_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('before_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tne_tpose_pose(temp: Ptr, pose: Ptr): Ptr {
-	const _r = callPtr('tne_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+export function overbefore_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('overbefore_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-
-// === meos_quadbin.h ===
-
-export function quadbin_in(str: string): number {
-	const _r = Number(call<bigint>('quadbin_in_w', 'bigint', ['string'], [str]));
+export function after_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('after_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_eq(a: number, b: number): boolean {
-	const _r = call<number>('quadbin_eq_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0;
+export function overafter_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean {
+	const _r = call<number>('overafter_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_ne(a: number, b: number): boolean {
-	const _r = call<number>('quadbin_ne_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0;
+export function tpointcloud_to_tgeompoint(temp: Ptr): Ptr {
+	const _r = callPtr('tpointcloud_to_tgeompoint_w', [ptrArgType()], [ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_lt(a: number, b: number): boolean {
-	const _r = call<number>('quadbin_lt_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0;
+export function tpcpatch_to_tgeometry(temp: Ptr): Ptr {
+	const _r = callPtr('tpcpatch_to_tgeometry_w', [ptrArgType()], [ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_le(a: number, b: number): boolean {
-	const _r = call<number>('quadbin_le_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0;
+export function tpcpointinst_make(pt: Ptr, t: TimestampTz): Ptr {
+	const _r = callPtr('tpcpointinst_make_w', [ptrArgType(), 'bigint'], [ptrArgVal(pt), BigInt(t)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_gt(a: number, b: number): boolean {
-	const _r = call<number>('quadbin_gt_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0;
+export function tpcpointseq_from_base_tstzset(pt: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('tpcpointseq_from_base_tstzset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(s)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_ge(a: number, b: number): boolean {
-	const _r = call<number>('quadbin_ge_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0;
+export function tpcpointseq_from_base_tstzspan(pt: Ptr, sp: Ptr): Ptr {
+	const _r = callPtr('tpcpointseq_from_base_tstzspan_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(sp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_cmp(a: number, b: number): number {
-	const _r = call<number>('quadbin_cmp_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]);
+export function tpcpointseqset_from_base_tstzspanset(pt: Ptr, ss: Ptr): Ptr {
+	const _r = callPtr('tpcpointseqset_from_base_tstzspanset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(ss)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_hash(cell: number): number {
-	const _r = call<number>('quadbin_hash_w', 'number', ['bigint'], [BigInt(cell)]);
+export function tpcpoint_from_base_temp(pt: Ptr, temp: Ptr): Ptr {
+	const _r = callPtr('tpcpoint_from_base_temp_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_hash_extended(cell: number, seed: number): number {
-	const _r = Number(call<bigint>('quadbin_hash_extended_w', 'bigint', ['bigint', 'bigint'], [BigInt(cell), BigInt(seed)]));
+export function tpcpoint_start_value(temp: Ptr): Ptr {
+	const _r = callPtr('tpcpoint_start_value_w', [ptrArgType()], [ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_is_valid_index(index: number): boolean {
-	const _r = call<number>('quadbin_is_valid_index_w', 'number', ['bigint'], [BigInt(index)]) !== 0;
+export function tpcpoint_end_value(temp: Ptr): Ptr {
+	const _r = callPtr('tpcpoint_end_value_w', [ptrArgType()], [ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_is_valid_cell(cell: number): boolean {
-	const _r = call<number>('quadbin_is_valid_cell_w', 'number', ['bigint'], [BigInt(cell)]) !== 0;
+export function tpcpoint_value_n(temp: Ptr, n: number): Ptr {
+	const _r = callPtr('tpcpoint_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), n]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_tile_to_cell(x: number, y: number, z: number): number {
-	const _r = Number(call<bigint>('quadbin_tile_to_cell_w', 'bigint', ['number', 'number', 'number'], [x, y, z]));
+export function tpcpoint_values(temp: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('tpcpoint_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_cell_to_tile(cell: number, x: Ptr, y: Ptr, z: Ptr): boolean {
-	const _r = call<number>('quadbin_cell_to_tile_w', 'number', ['bigint', ptrArgType(), ptrArgType(), ptrArgType()], [BigInt(cell), ptrArgVal(x), ptrArgVal(y), ptrArgVal(z)]) !== 0;
+export function tpcpoint_value_at_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean, value: Ptr): boolean {
+	const _r = call<number>('tpcpoint_value_at_timestamptz_w', 'number', [ptrArgType(), 'bigint', 'number', ptrArgType()], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0, ptrArgVal(value)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_get_resolution(cell: number): number {
-	const _r = call<number>('quadbin_get_resolution_w', 'number', ['bigint'], [BigInt(cell)]);
+export function tpcpoint_at_value(temp: Ptr, pt: Ptr): Ptr {
+	const _r = callPtr('tpcpoint_at_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_cell_to_parent(cell: number, parent_resolution: number): number {
-	const _r = Number(call<bigint>('quadbin_cell_to_parent_w', 'bigint', ['bigint', 'number'], [BigInt(cell), parent_resolution]));
+export function tpcpoint_minus_value(temp: Ptr, pt: Ptr): Ptr {
+	const _r = callPtr('tpcpoint_minus_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_cell_to_children(cell: number, children_resolution: number, count: Ptr): Ptr {
-	const _r = callPtr('quadbin_cell_to_children_w', ['bigint', 'number', ptrArgType()], [BigInt(cell), children_resolution, ptrArgVal(count)]);
+export function tpcpatchinst_make(pa: Ptr, t: TimestampTz): Ptr {
+	const _r = callPtr('tpcpatchinst_make_w', [ptrArgType(), 'bigint'], [ptrArgVal(pa), BigInt(t)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_cell_sibling(cell: number, direction: string): number {
-	const _r = Number(call<bigint>('quadbin_cell_sibling_w', 'bigint', ['bigint', 'string'], [BigInt(cell), direction]));
+export function tpcpatchseq_from_base_tstzset(pa: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('tpcpatchseq_from_base_tstzset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(s)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_k_ring(cell: number, k: number, count: Ptr): Ptr {
-	const _r = callPtr('quadbin_k_ring_w', ['bigint', 'number', ptrArgType()], [BigInt(cell), k, ptrArgVal(count)]);
+export function tpcpatchseq_from_base_tstzspan(pa: Ptr, sp: Ptr): Ptr {
+	const _r = callPtr('tpcpatchseq_from_base_tstzspan_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(sp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_point_to_cell(longitude: number, latitude: number, resolution: number): number {
-	const _r = Number(call<bigint>('quadbin_point_to_cell_w', 'bigint', ['number', 'number', 'number'], [longitude, latitude, resolution]));
+export function tpcpatchseqset_from_base_tstzspanset(pa: Ptr, ss: Ptr): Ptr {
+	const _r = callPtr('tpcpatchseqset_from_base_tstzspanset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(ss)]);
 	checkMeosError();
 	return _r;
 }
 
-export function geo_to_quadbin_cell(point: Ptr, resolution: number): number {
-	const _r = Number(call<bigint>('geo_to_quadbin_cell_w', 'bigint', [ptrArgType(), 'number'], [ptrArgVal(point), resolution]));
+export function tpcpatch_from_base_temp(pa: Ptr, temp: Ptr): Ptr {
+	const _r = callPtr('tpcpatch_from_base_temp_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_cell_to_geompoint(cell: number): Ptr {
-	const _r = callPtr('quadbin_cell_to_geompoint_w', ['bigint'], [BigInt(cell)]);
+export function tpcpatch_start_value(temp: Ptr): Ptr {
+	const _r = callPtr('tpcpatch_start_value_w', [ptrArgType()], [ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_cell_to_geom(cell: number): Ptr {
-	const _r = callPtr('quadbin_cell_to_geom_w', ['bigint'], [BigInt(cell)]);
+export function tpcpatch_end_value(temp: Ptr): Ptr {
+	const _r = callPtr('tpcpatch_end_value_w', [ptrArgType()], [ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_to_stbox(cell: number): Ptr {
-	const _r = callPtr('quadbin_to_stbox_w', ['bigint'], [BigInt(cell)]);
+export function tpcpatch_value_n(temp: Ptr, n: number): Ptr {
+	const _r = callPtr('tpcpatch_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), n]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_timestamptz_to_stbox(cell: number, t: TimestampTz): Ptr {
-	const _r = callPtr('quadbin_timestamptz_to_stbox_w', ['bigint', 'bigint'], [BigInt(cell), BigInt(t)]);
+export function tpcpatch_values(temp: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('tpcpatch_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_tstzspan_to_stbox(cell: number, s: Ptr): Ptr {
-	const _r = callPtr('quadbin_tstzspan_to_stbox_w', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(s)]);
+export function tpcpatch_value_at_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean, value: Ptr): boolean {
+	const _r = call<number>('tpcpatch_value_at_timestamptz_w', 'number', [ptrArgType(), 'bigint', 'number', ptrArgType()], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0, ptrArgVal(value)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_cell_area(cell: number): number {
-	const _r = call<number>('quadbin_cell_area_w', 'number', ['bigint'], [BigInt(cell)]);
+export function tpcpatch_at_value(temp: Ptr, pa: Ptr): Ptr {
+	const _r = callPtr('tpcpatch_at_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_index_to_string(index: number): string {
-	const _r = call<string>('quadbin_index_to_string_w', 'string', ['bigint'], [BigInt(index)]);
+export function tpcpatch_minus_value(temp: Ptr, pa: Ptr): Ptr {
+	const _r = callPtr('tpcpatch_minus_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_string_to_index(str: string): number {
-	const _r = Number(call<bigint>('quadbin_string_to_index_w', 'bigint', ['string'], [str]));
+export function ever_eq_pcpoint_tpcpoint(pt: Ptr, temp: Ptr): number {
+	const _r = call<number>('ever_eq_pcpoint_tpcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_cell_to_quadkey(cell: number): string {
-	const _r = call<string>('quadbin_cell_to_quadkey_w', 'string', ['bigint'], [BigInt(cell)]);
+export function ever_eq_tpcpoint_pcpoint(temp: Ptr, pt: Ptr): number {
+	const _r = call<number>('ever_eq_tpcpoint_pcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_grid_disk(origin: number, k: number): Ptr {
-	const _r = callPtr('quadbin_grid_disk_w', ['bigint', 'number'], [BigInt(origin), k]);
+export function ever_eq_tpcpoint_tpcpoint(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('ever_eq_tpcpoint_tpcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_cell_to_children_set(origin: number, children_resolution: number): Ptr {
-	const _r = callPtr('quadbin_cell_to_children_set_w', ['bigint', 'number'], [BigInt(origin), children_resolution]);
+export function ever_ne_pcpoint_tpcpoint(pt: Ptr, temp: Ptr): number {
+	const _r = call<number>('ever_ne_pcpoint_tpcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tquadbin_in(str: string): Ptr {
-	const _r = callPtr('tquadbin_in_w', ['string'], [str]);
+export function ever_ne_tpcpoint_pcpoint(temp: Ptr, pt: Ptr): number {
+	const _r = call<number>('ever_ne_tpcpoint_pcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tquadbininst_in(str: string): Ptr {
-	const _r = callPtr('tquadbininst_in_w', ['string'], [str]);
+export function ever_ne_tpcpoint_tpcpoint(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('ever_ne_tpcpoint_tpcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tquadbinseq_in(str: string, interp: number): Ptr {
-	const _r = callPtr('tquadbinseq_in_w', ['string', 'number'], [str, interp]);
+export function always_eq_pcpoint_tpcpoint(pt: Ptr, temp: Ptr): number {
+	const _r = call<number>('always_eq_pcpoint_tpcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tquadbinseqset_in(str: string): Ptr {
-	const _r = callPtr('tquadbinseqset_in_w', ['string'], [str]);
+export function always_eq_tpcpoint_pcpoint(temp: Ptr, pt: Ptr): number {
+	const _r = call<number>('always_eq_tpcpoint_pcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tquadbin_make(value: number, t: TimestampTz): Ptr {
-	const _r = callPtr('tquadbin_make_w', ['bigint', 'bigint'], [BigInt(value), BigInt(t)]);
+export function always_eq_tpcpoint_tpcpoint(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('always_eq_tpcpoint_tpcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tquadbininst_make(value: number, t: TimestampTz): Ptr {
-	const _r = callPtr('tquadbininst_make_w', ['bigint', 'bigint'], [BigInt(value), BigInt(t)]);
+export function always_ne_pcpoint_tpcpoint(pt: Ptr, temp: Ptr): number {
+	const _r = call<number>('always_ne_pcpoint_tpcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tquadbinseq_make(values: Ptr, times: Ptr, count: number, lower_inc: boolean, upper_inc: boolean): Ptr {
-	const _r = callPtr('tquadbinseq_make_w', [ptrArgType(), ptrArgType(), 'number', 'number', 'number'], [ptrArgVal(values), ptrArgVal(times), count, lower_inc ? 1 : 0, upper_inc ? 1 : 0]);
+export function always_ne_tpcpoint_pcpoint(temp: Ptr, pt: Ptr): number {
+	const _r = call<number>('always_ne_tpcpoint_pcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tquadbinseqset_make(sequences: Ptr, count: number): Ptr {
-	const _r = callPtr('tquadbinseqset_make_w', [ptrArgType(), 'number'], [ptrArgVal(sequences), count]);
+export function always_ne_tpcpoint_tpcpoint(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('always_ne_tpcpoint_tpcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tquadbin_start_value(temp: Ptr): number {
-	const _r = Number(call<bigint>('tquadbin_start_value_w', 'bigint', [ptrArgType()], [ptrArgVal(temp)]));
+export function ever_eq_pcpatch_tpcpatch(pa: Ptr, temp: Ptr): number {
+	const _r = call<number>('ever_eq_pcpatch_tpcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tquadbin_end_value(temp: Ptr): number {
-	const _r = Number(call<bigint>('tquadbin_end_value_w', 'bigint', [ptrArgType()], [ptrArgVal(temp)]));
+export function ever_eq_tpcpatch_pcpatch(temp: Ptr, pa: Ptr): number {
+	const _r = call<number>('ever_eq_tpcpatch_pcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tquadbin_value_n(temp: Ptr, n: number): number {
-	const _r = Number(call<bigint>('tquadbin_value_n_w', 'bigint', [ptrArgType(), 'number'], [ptrArgVal(temp), n]));
+export function ever_eq_tpcpatch_tpcpatch(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('ever_eq_tpcpatch_tpcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tquadbin_values(temp: Ptr, count: Ptr): Ptr {
-	const _r = callPtr('tquadbin_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]);
+export function ever_ne_pcpatch_tpcpatch(pa: Ptr, temp: Ptr): number {
+	const _r = call<number>('ever_ne_pcpatch_tpcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tquadbin_value_at_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): number {
-	const _r = Number(call<bigint>('tquadbin_value_at_timestamptz_w', 'bigint', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0]));
+export function ever_ne_tpcpatch_pcpatch(temp: Ptr, pa: Ptr): number {
+	const _r = call<number>('ever_ne_tpcpatch_pcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function quadbin_to_set(cell: number): Ptr {
-	const _r = callPtr('quadbin_to_set_w', ['bigint'], [BigInt(cell)]);
+export function ever_ne_tpcpatch_tpcpatch(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('ever_ne_tpcpatch_tpcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tbigint_to_tquadbin(temp: Ptr): Ptr {
-	const _r = callPtr('tbigint_to_tquadbin_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function always_eq_pcpatch_tpcpatch(pa: Ptr, temp: Ptr): number {
+	const _r = call<number>('always_eq_pcpatch_tpcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function tquadbin_to_tbigint(temp: Ptr): Ptr {
-	const _r = callPtr('tquadbin_to_tbigint_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function always_eq_tpcpatch_pcpatch(temp: Ptr, pa: Ptr): number {
+	const _r = call<number>('always_eq_tpcpatch_pcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function ever_eq_quadbin_tquadbin(cell: number, temp: Ptr): number {
-	const _r = call<number>('ever_eq_quadbin_tquadbin_w', 'number', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]);
+export function always_eq_tpcpatch_tpcpatch(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('always_eq_tpcpatch_tpcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function ever_eq_tquadbin_quadbin(temp: Ptr, cell: number): number {
-	const _r = call<number>('ever_eq_tquadbin_quadbin_w', 'number', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]);
+export function always_ne_pcpatch_tpcpatch(pa: Ptr, temp: Ptr): number {
+	const _r = call<number>('always_ne_pcpatch_tpcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function ever_ne_quadbin_tquadbin(cell: number, temp: Ptr): number {
-	const _r = call<number>('ever_ne_quadbin_tquadbin_w', 'number', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]);
+export function always_ne_tpcpatch_pcpatch(temp: Ptr, pa: Ptr): number {
+	const _r = call<number>('always_ne_tpcpatch_pcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function ever_ne_tquadbin_quadbin(temp: Ptr, cell: number): number {
-	const _r = call<number>('ever_ne_tquadbin_quadbin_w', 'number', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]);
+export function always_ne_tpcpatch_tpcpatch(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('always_ne_tpcpatch_tpcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function always_eq_quadbin_tquadbin(cell: number, temp: Ptr): number {
-	const _r = call<number>('always_eq_quadbin_tquadbin_w', 'number', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]);
+export function teq_pcpoint_tpcpoint(pt: Ptr, temp: Ptr): Ptr {
+	const _r = callPtr('teq_pcpoint_tpcpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function always_eq_tquadbin_quadbin(temp: Ptr, cell: number): number {
-	const _r = call<number>('always_eq_tquadbin_quadbin_w', 'number', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]);
+export function teq_tpcpoint_pcpoint(temp: Ptr, pt: Ptr): Ptr {
+	const _r = callPtr('teq_tpcpoint_pcpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function always_ne_quadbin_tquadbin(cell: number, temp: Ptr): number {
-	const _r = call<number>('always_ne_quadbin_tquadbin_w', 'number', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]);
+export function tne_pcpoint_tpcpoint(pt: Ptr, temp: Ptr): Ptr {
+	const _r = callPtr('tne_pcpoint_tpcpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function always_ne_tquadbin_quadbin(temp: Ptr, cell: number): number {
-	const _r = call<number>('always_ne_tquadbin_quadbin_w', 'number', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]);
+export function tne_tpcpoint_pcpoint(temp: Ptr, pt: Ptr): Ptr {
+	const _r = callPtr('tne_tpcpoint_pcpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pt)]);
 	checkMeosError();
 	return _r;
 }
 
-export function ever_eq_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('ever_eq_tquadbin_tquadbin_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function teq_pcpatch_tpcpatch(pa: Ptr, temp: Ptr): Ptr {
+	const _r = callPtr('teq_pcpatch_tpcpatch_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function ever_ne_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('ever_ne_tquadbin_tquadbin_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function teq_tpcpatch_pcpatch(temp: Ptr, pa: Ptr): Ptr {
+	const _r = callPtr('teq_tpcpatch_pcpatch_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function always_eq_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('always_eq_tquadbin_tquadbin_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function tne_pcpatch_tpcpatch(pa: Ptr, temp: Ptr): Ptr {
+	const _r = callPtr('tne_pcpatch_tpcpatch_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function always_ne_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('always_ne_tquadbin_tquadbin_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function tne_tpcpatch_pcpatch(temp: Ptr, pa: Ptr): Ptr {
+	const _r = callPtr('tne_tpcpatch_pcpatch_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pa)]);
 	checkMeosError();
 	return _r;
 }
 
-export function teq_quadbin_tquadbin(cell: number, temp: Ptr): Ptr {
-	const _r = callPtr('teq_quadbin_tquadbin_w', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]);
+export function adjacent_tpcbox_tpointcloud(box: Ptr, temp: Ptr): boolean {
+	const _r = call<number>('adjacent_tpcbox_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box), ptrArgVal(temp)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function teq_tquadbin_quadbin(temp: Ptr, cell: number): Ptr {
-	const _r = callPtr('teq_tquadbin_quadbin_w', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]);
+export function adjacent_tpointcloud_tpcbox(temp: Ptr, box: Ptr): boolean {
+	const _r = call<number>('adjacent_tpointcloud_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function teq_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): Ptr {
-	const _r = callPtr('teq_tquadbin_tquadbin_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function adjacent_tpointcloud_tpointcloud(temp1: Ptr, temp2: Ptr): boolean {
+	const _r = call<number>('adjacent_tpointcloud_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tne_quadbin_tquadbin(cell: number, temp: Ptr): Ptr {
-	const _r = callPtr('tne_quadbin_tquadbin_w', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]);
+export function contained_tpcbox_tpointcloud(box: Ptr, temp: Ptr): boolean {
+	const _r = call<number>('contained_tpcbox_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box), ptrArgVal(temp)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tne_tquadbin_quadbin(temp: Ptr, cell: number): Ptr {
-	const _r = callPtr('tne_tquadbin_quadbin_w', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]);
+export function contained_tpointcloud_tpcbox(temp: Ptr, box: Ptr): boolean {
+	const _r = call<number>('contained_tpointcloud_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tne_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): Ptr {
-	const _r = callPtr('tne_tquadbin_tquadbin_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function contained_tpointcloud_tpointcloud(temp1: Ptr, temp2: Ptr): boolean {
+	const _r = call<number>('contained_tpointcloud_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tquadbin_cell_to_quadkey(temp: Ptr): Ptr {
-	const _r = callPtr('tquadbin_cell_to_quadkey_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function contains_tpcbox_tpointcloud(box: Ptr, temp: Ptr): boolean {
+	const _r = call<number>('contains_tpcbox_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box), ptrArgVal(temp)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-
-// === meos_rgeo.h ===
-
-export function trgeometry_in(str: string): Ptr {
-	const _r = callPtr('trgeometry_in_w', ['string'], [str]);
+export function contains_tpointcloud_tpcbox(temp: Ptr, box: Ptr): boolean {
+	const _r = call<number>('contains_tpointcloud_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_from_mfjson(mfjson: string): Ptr {
-	const _r = callPtr('trgeometry_from_mfjson_w', ['string'], [mfjson]);
+export function contains_tpointcloud_tpointcloud(temp1: Ptr, temp2: Ptr): boolean {
+	const _r = call<number>('contains_tpointcloud_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_out(temp: Ptr): string {
-	const _r = call<string>('trgeometry_out_w', 'string', [ptrArgType()], [ptrArgVal(temp)]);
+export function overlaps_tpcbox_tpointcloud(box: Ptr, temp: Ptr): boolean {
+	const _r = call<number>('overlaps_tpcbox_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box), ptrArgVal(temp)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_as_text(temp: Ptr, maxdd: number): string {
-	const _r = call<string>('trgeometry_as_text_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(temp), maxdd]);
+export function overlaps_tpointcloud_tpcbox(temp: Ptr, box: Ptr): boolean {
+	const _r = call<number>('overlaps_tpointcloud_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_as_ewkt(temp: Ptr, maxdd: number): string {
-	const _r = call<string>('trgeometry_as_ewkt_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(temp), maxdd]);
+export function overlaps_tpointcloud_tpointcloud(temp1: Ptr, temp2: Ptr): boolean {
+	const _r = call<number>('overlaps_tpointcloud_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometryinst_make(geom: Ptr, pose: Ptr, t: TimestampTz): Ptr {
-	const _r = callPtr('trgeometryinst_make_w', [ptrArgType(), ptrArgType(), 'bigint'], [ptrArgVal(geom), ptrArgVal(pose), BigInt(t)]);
+export function same_tpcbox_tpointcloud(box: Ptr, temp: Ptr): boolean {
+	const _r = call<number>('same_tpcbox_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box), ptrArgVal(temp)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometryseq_make(geom: Ptr, instants: Ptr, count: number, lower_inc: boolean, upper_inc: boolean, interp: number, normalize: boolean): Ptr {
-	const _r = callPtr('trgeometryseq_make_w', [ptrArgType(), ptrArgType(), 'number', 'number', 'number', 'number', 'number'], [ptrArgVal(geom), ptrArgVal(instants), count, lower_inc ? 1 : 0, upper_inc ? 1 : 0, interp, normalize ? 1 : 0]);
+export function same_tpointcloud_tpcbox(temp: Ptr, box: Ptr): boolean {
+	const _r = call<number>('same_tpointcloud_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometryseqset_make(geom: Ptr, sequences: Ptr, count: number, normalize: boolean): Ptr {
-	const _r = callPtr('trgeometryseqset_make_w', [ptrArgType(), ptrArgType(), 'number', 'number'], [ptrArgVal(geom), ptrArgVal(sequences), count, normalize ? 1 : 0]);
+export function same_tpointcloud_tpointcloud(temp1: Ptr, temp2: Ptr): boolean {
+	const _r = call<number>('same_tpointcloud_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometryseqset_make_gaps(geom: Ptr, instants: Ptr, count: number, interp: number, maxt: Ptr, maxdist: number): Ptr {
-	const _r = callPtr('trgeometryseqset_make_gaps_w', [ptrArgType(), ptrArgType(), 'number', 'number', ptrArgType(), 'number'], [ptrArgVal(geom), ptrArgVal(instants), count, interp, ptrArgVal(maxt), maxdist]);
+export function eintersects_tpcpoint_geo(temp: Ptr, gs: Ptr): boolean {
+	const _r = call<number>('eintersects_tpcpoint_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function geometry_tpose_to_trgeometry(gs: Ptr, temp: Ptr): Ptr {
-	const _r = callPtr('geometry_tpose_to_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+export function nad_tpcpoint_geo(temp: Ptr, gs: Ptr): number {
+	const _r = call<number>('nad_tpcpoint_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_to_tpose(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_to_tpose_w', [ptrArgType()], [ptrArgVal(temp)]);
+
+// === meos_pose.h ===
+
+export function pose_as_ewkt(pose: Ptr, maxdd: number): string {
+	const _r = call<string>('pose_as_ewkt_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pose), maxdd]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_to_tgeompoint(temp: Ptr): Ptr {
+export function pose_as_hexwkb(pose: Ptr, variant: number, size_out: Ptr): string {
+	const _r = call<string>('pose_as_hexwkb_w', 'string', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(pose), variant, ptrArgVal(size_out)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_as_text(pose: Ptr, maxdd: number): string {
+	const _r = call<string>('pose_as_text_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pose), maxdd]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_as_wkb(pose: Ptr, variant: number, size_out: Ptr): Ptr {
+	const _r = callPtr('pose_as_wkb_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(pose), variant, ptrArgVal(size_out)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_from_wkb(wkb: Ptr, size: number): Ptr {
+	const _r = callPtr('pose_from_wkb_w', [ptrArgType(), 'number'], [ptrArgVal(wkb), size]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_from_hexwkb(hexwkb: string): Ptr {
+	const _r = callPtr('pose_from_hexwkb_w', ['string'], [hexwkb]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_in(str: string): Ptr {
+	const _r = callPtr('pose_in_w', ['string'], [str]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_out(pose: Ptr, maxdd: number): string {
+	const _r = call<string>('pose_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pose), maxdd]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_from_geopose(json: string): Ptr {
+	const _r = callPtr('pose_from_geopose_w', ['string'], [json]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_as_geopose(pose: Ptr, conformance: number, precision: number): string {
+	const _r = call<string>('pose_as_geopose_w', 'string', [ptrArgType(), 'number', 'number'], [ptrArgVal(pose), conformance, precision]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_from_geopose(json: string): Ptr {
+	const _r = callPtr('tpose_from_geopose_w', ['string'], [json]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_as_geopose(temp: Ptr, conformance: number, precision: number): string {
+	const _r = call<string>('tpose_as_geopose_w', 'string', [ptrArgType(), 'number', 'number'], [ptrArgVal(temp), conformance, precision]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_as_geopose_stream_element(temp: Ptr, inst: Ptr, precision: number): string {
+	const _r = call<string>('tpose_as_geopose_stream_element_w', 'string', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(inst), precision]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_as_geopose_stream(temp: Ptr, precision: number): string {
+	const _r = call<string>('tpose_as_geopose_stream_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(temp), precision]);
+	checkMeosError();
+	return _r;
+}
+
+export function geopose_frames(count: Ptr): Ptr {
+	const _r = callPtr('geopose_frames_w', [ptrArgType()], [ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function geopose_frame(frame_id: number): Ptr {
+	const _r = callPtr('geopose_frame_w', ['number'], [frame_id]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_apply_geo(pose: Ptr, body: Ptr): Ptr {
+	const _r = callPtr('pose_apply_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(body)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_apply_geo(temp: Ptr, body: Ptr): Ptr {
+	const _r = callPtr('tpose_apply_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(body)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_compose_pose(body: Ptr, frame: Ptr): Ptr {
+	const _r = callPtr('tpose_compose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(body), ptrArgVal(frame)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_compose_tpose(body: Ptr, frame: Ptr): Ptr {
+	const _r = callPtr('pose_compose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(body), ptrArgVal(frame)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_compose_tpose(body: Ptr, frame: Ptr): Ptr {
+	const _r = callPtr('tpose_compose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(body), ptrArgVal(frame)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_inverse(temp: Ptr): Ptr {
+	const _r = callPtr('tpose_inverse_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_copy(pose: Ptr): Ptr {
+	const _r = callPtr('pose_copy_w', [ptrArgType()], [ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_make_2d(x: number, y: number, theta: number, geodetic: boolean, srid: number): Ptr {
+	const _r = callPtr('pose_make_2d_w', ['number', 'number', 'number', 'number', 'number'], [x, y, theta, geodetic ? 1 : 0, srid]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_make_3d(x: number, y: number, z: number, W: number, X: number, Y: number, Z: number, geodetic: boolean, srid: number): Ptr {
+	const _r = callPtr('pose_make_3d_w', ['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number'], [x, y, z, W, X, Y, Z, geodetic ? 1 : 0, srid]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_make_point2d(gs: Ptr, theta: number): Ptr {
+	const _r = callPtr('pose_make_point2d_w', [ptrArgType(), 'number'], [ptrArgVal(gs), theta]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_make_point3d(gs: Ptr, W: number, X: number, Y: number, Z: number): Ptr {
+	const _r = callPtr('pose_make_point3d_w', [ptrArgType(), 'number', 'number', 'number', 'number'], [ptrArgVal(gs), W, X, Y, Z]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_make_point3d_ypr(gs: Ptr, yaw: number, pitch: number, roll: number): Ptr {
+	const _r = callPtr('pose_make_point3d_ypr_w', [ptrArgType(), 'number', 'number', 'number'], [ptrArgVal(gs), yaw, pitch, roll]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_to_point(pose: Ptr): Ptr {
+	const _r = callPtr('pose_to_point_w', [ptrArgType()], [ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_to_stbox(pose: Ptr): Ptr {
+	const _r = callPtr('pose_to_stbox_w', [ptrArgType()], [ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_hash(pose: Ptr): number {
+	const _r = call<number>('pose_hash_w', 'number', [ptrArgType()], [ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_hash_extended(pose: Ptr, seed: number): number {
+	const _r = Number(call<bigint>('pose_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(pose), BigInt(seed)]));
+	checkMeosError();
+	return _r;
+}
+
+export function pose_quaternion(pose: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('pose_quaternion_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_ypr(pose: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('pose_ypr_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_yaw(pose: Ptr): number {
+	const _r = call<number>('pose_yaw_w', 'number', [ptrArgType()], [ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_pitch(pose: Ptr): number {
+	const _r = call<number>('pose_pitch_w', 'number', [ptrArgType()], [ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_roll(pose: Ptr): number {
+	const _r = call<number>('pose_roll_w', 'number', [ptrArgType()], [ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_angular_distance(pose1: Ptr, pose2: Ptr): number {
+	const _r = call<number>('pose_angular_distance_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_compose(body: Ptr, frame: Ptr): Ptr {
+	const _r = callPtr('pose_compose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(body), ptrArgVal(frame)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_inverse(pose: Ptr): Ptr {
+	const _r = callPtr('pose_inverse_w', [ptrArgType()], [ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_normalize(pose: Ptr): Ptr {
+	const _r = callPtr('pose_normalize_w', [ptrArgType()], [ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_round(pose: Ptr, maxdd: number): Ptr {
+	const _r = callPtr('pose_round_w', [ptrArgType(), 'number'], [ptrArgVal(pose), maxdd]);
+	checkMeosError();
+	return _r;
+}
+
+export function posearr_round(posearr: Ptr, count: number, maxdd: number): Ptr {
+	const _r = callPtr('posearr_round_w', [ptrArgType(), 'number', 'number'], [ptrArgVal(posearr), count, maxdd]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_set_srid(pose: Ptr, srid: number): Ptr {
+	const _r = callPtr('pose_set_srid_w', [ptrArgType(), 'number'], [ptrArgVal(pose), srid]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_srid(pose: Ptr): number {
+	const _r = call<number>('pose_srid_w', 'number', [ptrArgType()], [ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_transform(pose: Ptr, srid: number): Ptr {
+	const _r = callPtr('pose_transform_w', [ptrArgType(), 'number'], [ptrArgVal(pose), srid]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_transform_pipeline(pose: Ptr, pipelinestr: string, srid: number, is_forward: boolean): Ptr {
+	const _r = callPtr('pose_transform_pipeline_w', [ptrArgType(), 'string', 'number', 'number'], [ptrArgVal(pose), pipelinestr, srid, is_forward ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_tstzspan_to_stbox(pose: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('pose_tstzspan_to_stbox_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_timestamptz_to_stbox(pose: Ptr, t: TimestampTz): Ptr {
+	const _r = callPtr('pose_timestamptz_to_stbox_w', [ptrArgType(), 'bigint'], [ptrArgVal(pose), BigInt(t)]);
+	checkMeosError();
+	return _r;
+}
+
+export function distance_pose_geo(pose: Ptr, gs: Ptr): number {
+	const _r = call<number>('distance_pose_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function distance_pose_pose(pose1: Ptr, pose2: Ptr): number {
+	const _r = call<number>('distance_pose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function distance_pose_stbox(pose: Ptr, box: Ptr): number {
+	const _r = call<number>('distance_pose_stbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(box)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_cmp(pose1: Ptr, pose2: Ptr): number {
+	const _r = call<number>('pose_cmp_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_eq(pose1: Ptr, pose2: Ptr): boolean {
+	const _r = call<number>('pose_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function pose_ge(pose1: Ptr, pose2: Ptr): boolean {
+	const _r = call<number>('pose_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function pose_gt(pose1: Ptr, pose2: Ptr): boolean {
+	const _r = call<number>('pose_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function pose_le(pose1: Ptr, pose2: Ptr): boolean {
+	const _r = call<number>('pose_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function pose_lt(pose1: Ptr, pose2: Ptr): boolean {
+	const _r = call<number>('pose_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function pose_ne(pose1: Ptr, pose2: Ptr): boolean {
+	const _r = call<number>('pose_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function pose_nsame(pose1: Ptr, pose2: Ptr): boolean {
+	const _r = call<number>('pose_nsame_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function pose_same(pose1: Ptr, pose2: Ptr): boolean {
+	const _r = call<number>('pose_same_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function poseset_in(str: string): Ptr {
+	const _r = callPtr('poseset_in_w', ['string'], [str]);
+	checkMeosError();
+	return _r;
+}
+
+export function poseset_out(s: Ptr, maxdd: number): string {
+	const _r = call<string>('poseset_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(s), maxdd]);
+	checkMeosError();
+	return _r;
+}
+
+export function poseset_make(values: Ptr, count: number): Ptr {
+	const _r = callPtr('poseset_make_w', [ptrArgType(), 'number'], [ptrArgVal(values), count]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_to_set(pose: Ptr): Ptr {
+	const _r = callPtr('pose_to_set_w', [ptrArgType()], [ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function poseset_end_value(s: Ptr): Ptr {
+	const _r = callPtr('poseset_end_value_w', [ptrArgType()], [ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function poseset_start_value(s: Ptr): Ptr {
+	const _r = callPtr('poseset_start_value_w', [ptrArgType()], [ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function poseset_value_n(s: Ptr, n: number): Ptr {
+	const _r = callPtr('poseset_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(s), n]);
+	checkMeosError();
+	return _r;
+}
+
+export function poseset_values(s: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('poseset_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function contained_pose_set(pose: Ptr, s: Ptr): boolean {
+	const _r = call<number>('contained_pose_set_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function contains_set_pose(s: Ptr, pose: Ptr): boolean {
+	const _r = call<number>('contains_set_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pose)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function intersection_pose_set(pose: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('intersection_pose_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function intersection_set_pose(s: Ptr, pose: Ptr): Ptr {
+	const _r = callPtr('intersection_set_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function minus_pose_set(pose: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('minus_pose_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function minus_set_pose(s: Ptr, pose: Ptr): Ptr {
+	const _r = callPtr('minus_set_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_union_transfn(state: Ptr, pose: Ptr): Ptr {
+	const _r = callPtr('pose_union_transfn_w', [ptrArgType(), ptrArgType()], [ptrArgVal(state), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function union_pose_set(pose: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('union_pose_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function union_set_pose(s: Ptr, pose: Ptr): Ptr {
+	const _r = callPtr('union_set_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_from_mfjson(str: string): Ptr {
+	const _r = callPtr('tpose_from_mfjson_w', ['string'], [str]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_in(str: string): Ptr {
+	const _r = callPtr('tpose_in_w', ['string'], [str]);
+	checkMeosError();
+	return _r;
+}
+
+export function tposeinst_make(pose: Ptr, t: TimestampTz): Ptr {
+	const _r = callPtr('tposeinst_make_w', [ptrArgType(), 'bigint'], [ptrArgVal(pose), BigInt(t)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_from_base_temp(pose: Ptr, temp: Ptr): Ptr {
+	const _r = callPtr('tpose_from_base_temp_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tposeseq_from_base_tstzset(pose: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('tposeseq_from_base_tstzset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tposeseq_from_base_tstzspan(pose: Ptr, s: Ptr, interp: number): Ptr {
+	const _r = callPtr('tposeseq_from_base_tstzspan_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(pose), ptrArgVal(s), interp]);
+	checkMeosError();
+	return _r;
+}
+
+export function tposeseqset_from_base_tstzspanset(pose: Ptr, ss: Ptr, interp: number): Ptr {
+	const _r = callPtr('tposeseqset_from_base_tstzspanset_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(pose), ptrArgVal(ss), interp]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_make(tpoint: Ptr, ttheta: Ptr): Ptr {
+	const _r = callPtr('tpose_make_w', [ptrArgType(), ptrArgType()], [ptrArgVal(tpoint), ptrArgVal(ttheta)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_to_tpoint(temp: Ptr): Ptr {
+	const _r = callPtr('tpose_to_tpoint_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_end_value(temp: Ptr): Ptr {
+	const _r = callPtr('tpose_end_value_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_points(temp: Ptr): Ptr {
+	const _r = callPtr('tpose_points_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_yaw(temp: Ptr): Ptr {
+	const _r = callPtr('tpose_yaw_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_pitch(temp: Ptr): Ptr {
+	const _r = callPtr('tpose_pitch_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_roll(temp: Ptr): Ptr {
+	const _r = callPtr('tpose_roll_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_speed(temp: Ptr): Ptr {
+	const _r = callPtr('tpose_speed_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_angular_speed(temp: Ptr): Ptr {
+	const _r = callPtr('tpose_angular_speed_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_start_value(temp: Ptr): Ptr {
+	const _r = callPtr('tpose_start_value_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_trajectory(temp: Ptr): Ptr {
+	const _r = callPtr('tpose_trajectory_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_value_at_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): Ptr {
+	const _r = callPtr('tpose_value_at_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_value_n(temp: Ptr, n: number): Ptr {
+	const _r = callPtr('tpose_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), n]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_values(temp: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('tpose_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_at_elevation(temp: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('tpose_at_elevation_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_at_geom(temp: Ptr, gs: Ptr): Ptr {
+	const _r = callPtr('tpose_at_geom_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_at_stbox(temp: Ptr, box: Ptr, border_inc: boolean): Ptr {
+	const _r = callPtr('tpose_at_stbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(box), border_inc ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_at_pose(temp: Ptr, pose: Ptr): Ptr {
+	const _r = callPtr('tpose_at_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_minus_elevation(temp: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('tpose_minus_elevation_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_minus_geom(temp: Ptr, gs: Ptr): Ptr {
+	const _r = callPtr('tpose_minus_geom_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_minus_pose(temp: Ptr, pose: Ptr): Ptr {
+	const _r = callPtr('tpose_minus_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tpose_minus_stbox(temp: Ptr, box: Ptr, border_inc: boolean): Ptr {
+	const _r = callPtr('tpose_minus_stbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(box), border_inc ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function tdistance_tpose_pose(temp: Ptr, pose: Ptr): Ptr {
+	const _r = callPtr('tdistance_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tdistance_tpose_geo(temp: Ptr, gs: Ptr): Ptr {
+	const _r = callPtr('tdistance_tpose_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tdistance_tpose_tpose(temp1: Ptr, temp2: Ptr): Ptr {
+	const _r = callPtr('tdistance_tpose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function nad_tpose_geo(temp: Ptr, gs: Ptr): number {
+	const _r = call<number>('nad_tpose_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function nad_tpose_pose(temp: Ptr, pose: Ptr): number {
+	const _r = call<number>('nad_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function nad_tpose_stbox(temp: Ptr, box: Ptr): number {
+	const _r = call<number>('nad_tpose_stbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]);
+	checkMeosError();
+	return _r;
+}
+
+export function nad_tpose_tpose(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('nad_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function nai_tpose_geo(temp: Ptr, gs: Ptr): Ptr {
+	const _r = callPtr('nai_tpose_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function nai_tpose_pose(temp: Ptr, pose: Ptr): Ptr {
+	const _r = callPtr('nai_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function nai_tpose_tpose(temp1: Ptr, temp2: Ptr): Ptr {
+	const _r = callPtr('nai_tpose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function shortestline_tpose_geo(temp: Ptr, gs: Ptr): Ptr {
+	const _r = callPtr('shortestline_tpose_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function shortestline_tpose_pose(temp: Ptr, pose: Ptr): Ptr {
+	const _r = callPtr('shortestline_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function shortestline_tpose_tpose(temp1: Ptr, temp2: Ptr): Ptr {
+	const _r = callPtr('shortestline_tpose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_eq_pose_tpose(pose: Ptr, temp: Ptr): number {
+	const _r = call<number>('always_eq_pose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_eq_tpose_pose(temp: Ptr, pose: Ptr): number {
+	const _r = call<number>('always_eq_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_eq_tpose_tpose(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('always_eq_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_ne_pose_tpose(pose: Ptr, temp: Ptr): number {
+	const _r = call<number>('always_ne_pose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_ne_tpose_pose(temp: Ptr, pose: Ptr): number {
+	const _r = call<number>('always_ne_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_ne_tpose_tpose(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('always_ne_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_eq_pose_tpose(pose: Ptr, temp: Ptr): number {
+	const _r = call<number>('ever_eq_pose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_eq_tpose_pose(temp: Ptr, pose: Ptr): number {
+	const _r = call<number>('ever_eq_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_eq_tpose_tpose(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('ever_eq_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_ne_pose_tpose(pose: Ptr, temp: Ptr): number {
+	const _r = call<number>('ever_ne_pose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_ne_tpose_pose(temp: Ptr, pose: Ptr): number {
+	const _r = call<number>('ever_ne_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_ne_tpose_tpose(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('ever_ne_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function teq_pose_tpose(pose: Ptr, temp: Ptr): Ptr {
+	const _r = callPtr('teq_pose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function teq_tpose_pose(temp: Ptr, pose: Ptr): Ptr {
+	const _r = callPtr('teq_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tne_pose_tpose(pose: Ptr, temp: Ptr): Ptr {
+	const _r = callPtr('tne_pose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tne_tpose_pose(temp: Ptr, pose: Ptr): Ptr {
+	const _r = callPtr('tne_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_in(str: string): Ptr {
+	const _r = callPtr('posechain_in_w', ['string'], [str]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_out(pc: Ptr, maxdd: number): string {
+	const _r = call<string>('posechain_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pc), maxdd]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_as_text(pc: Ptr, maxdd: number): string {
+	const _r = call<string>('posechain_as_text_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pc), maxdd]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_as_ewkt(pc: Ptr, maxdd: number): string {
+	const _r = call<string>('posechain_as_ewkt_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pc), maxdd]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_as_wkb(pc: Ptr, variant: number, size_out: Ptr): Ptr {
+	const _r = callPtr('posechain_as_wkb_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(pc), variant, ptrArgVal(size_out)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_as_hexwkb(pc: Ptr, variant: number, size_out: Ptr): string {
+	const _r = call<string>('posechain_as_hexwkb_w', 'string', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(pc), variant, ptrArgVal(size_out)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_from_wkb(wkb: Ptr, size: number): Ptr {
+	const _r = callPtr('posechain_from_wkb_w', [ptrArgType(), 'number'], [ptrArgVal(wkb), size]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_from_hexwkb(hexwkb: string): Ptr {
+	const _r = callPtr('posechain_from_hexwkb_w', ['string'], [hexwkb]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_make(poses: Ptr, count: number): Ptr {
+	const _r = callPtr('posechain_make_w', [ptrArgType(), 'number'], [ptrArgVal(poses), count]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_copy(pc: Ptr): Ptr {
+	const _r = callPtr('posechain_copy_w', [ptrArgType()], [ptrArgVal(pc)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_append(pc: Ptr, pose: Ptr): Ptr {
+	const _r = callPtr('posechain_append_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pc), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function pose_to_posechain(pose: Ptr): Ptr {
+	const _r = callPtr('pose_to_posechain_w', [ptrArgType()], [ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_to_pose(pc: Ptr): Ptr {
+	const _r = callPtr('posechain_to_pose_w', [ptrArgType()], [ptrArgVal(pc)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_prefix_pose(pc: Ptr, n: number): Ptr {
+	const _r = callPtr('posechain_prefix_pose_w', [ptrArgType(), 'number'], [ptrArgVal(pc), n]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_to_point(pc: Ptr): Ptr {
+	const _r = callPtr('posechain_to_point_w', [ptrArgType()], [ptrArgVal(pc)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_to_stbox(pc: Ptr): Ptr {
+	const _r = callPtr('posechain_to_stbox_w', [ptrArgType()], [ptrArgVal(pc)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_timestamptz_to_stbox(pc: Ptr, t: TimestampTz): Ptr {
+	const _r = callPtr('posechain_timestamptz_to_stbox_w', [ptrArgType(), 'bigint'], [ptrArgVal(pc), BigInt(t)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_tstzspan_to_stbox(pc: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('posechain_tstzspan_to_stbox_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pc), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_num_poses(pc: Ptr): number {
+	const _r = call<number>('posechain_num_poses_w', 'number', [ptrArgType()], [ptrArgVal(pc)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_start_pose(pc: Ptr): Ptr {
+	const _r = callPtr('posechain_start_pose_w', [ptrArgType()], [ptrArgVal(pc)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_end_pose(pc: Ptr): Ptr {
+	const _r = callPtr('posechain_end_pose_w', [ptrArgType()], [ptrArgVal(pc)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_pose_n(pc: Ptr, n: number): Ptr {
+	const _r = callPtr('posechain_pose_n_w', [ptrArgType(), 'number'], [ptrArgVal(pc), n]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_poses(pc: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('posechain_poses_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pc), ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_hash(pc: Ptr): number {
+	const _r = call<number>('posechain_hash_w', 'number', [ptrArgType()], [ptrArgVal(pc)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_hash_extended(pc: Ptr, seed: number): number {
+	const _r = Number(call<bigint>('posechain_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(pc), BigInt(seed)]));
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_round(pc: Ptr, maxdd: number): Ptr {
+	const _r = callPtr('posechain_round_w', [ptrArgType(), 'number'], [ptrArgVal(pc), maxdd]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_srid(pc: Ptr): number {
+	const _r = call<number>('posechain_srid_w', 'number', [ptrArgType()], [ptrArgVal(pc)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_set_srid(pc: Ptr, srid: number): Ptr {
+	const _r = callPtr('posechain_set_srid_w', [ptrArgType(), 'number'], [ptrArgVal(pc), srid]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_transform(pc: Ptr, srid_to: number): Ptr {
+	const _r = callPtr('posechain_transform_w', [ptrArgType(), 'number'], [ptrArgVal(pc), srid_to]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_transform_pipeline(pc: Ptr, pipeline: string, srid_to: number, is_forward: boolean): Ptr {
+	const _r = callPtr('posechain_transform_pipeline_w', [ptrArgType(), 'string', 'number', 'number'], [ptrArgVal(pc), pipeline, srid_to, is_forward ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function tposechain_from_geopose(json: string): Ptr {
+	const _r = callPtr('tposechain_from_geopose_w', ['string'], [json]);
+	checkMeosError();
+	return _r;
+}
+
+export function tposechain_as_geopose(temp: Ptr, precision: number): string {
+	const _r = call<string>('tposechain_as_geopose_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(temp), precision]);
+	checkMeosError();
+	return _r;
+}
+
+export function tposechainarr_as_geopose(temparr: Ptr, count: number, precision: number): string {
+	const _r = call<string>('tposechainarr_as_geopose_w', 'string', [ptrArgType(), 'number', 'number'], [ptrArgVal(temparr), count, precision]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_eq(pc1: Ptr, pc2: Ptr): boolean {
+	const _r = call<number>('posechain_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_ne(pc1: Ptr, pc2: Ptr): boolean {
+	const _r = call<number>('posechain_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_same(pc1: Ptr, pc2: Ptr): boolean {
+	const _r = call<number>('posechain_same_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_nsame(pc1: Ptr, pc2: Ptr): boolean {
+	const _r = call<number>('posechain_nsame_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_cmp(pc1: Ptr, pc2: Ptr): number {
+	const _r = call<number>('posechain_cmp_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_lt(pc1: Ptr, pc2: Ptr): boolean {
+	const _r = call<number>('posechain_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_le(pc1: Ptr, pc2: Ptr): boolean {
+	const _r = call<number>('posechain_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_gt(pc1: Ptr, pc2: Ptr): boolean {
+	const _r = call<number>('posechain_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_ge(pc1: Ptr, pc2: Ptr): boolean {
+	const _r = call<number>('posechain_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function posechainset_in(str: string): Ptr {
+	const _r = callPtr('posechainset_in_w', ['string'], [str]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechainset_out(s: Ptr, maxdd: number): string {
+	const _r = call<string>('posechainset_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(s), maxdd]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechainset_make(values: Ptr, count: number): Ptr {
+	const _r = callPtr('posechainset_make_w', [ptrArgType(), 'number'], [ptrArgVal(values), count]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_to_set(pc: Ptr): Ptr {
+	const _r = callPtr('posechain_to_set_w', [ptrArgType()], [ptrArgVal(pc)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechainset_end_value(s: Ptr): Ptr {
+	const _r = callPtr('posechainset_end_value_w', [ptrArgType()], [ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechainset_start_value(s: Ptr): Ptr {
+	const _r = callPtr('posechainset_start_value_w', [ptrArgType()], [ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechainset_value_n(s: Ptr, n: number): Ptr {
+	const _r = callPtr('posechainset_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(s), n]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechainset_values(s: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('posechainset_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function contained_posechain_set(pc: Ptr, s: Ptr): boolean {
+	const _r = call<number>('contained_posechain_set_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc), ptrArgVal(s)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function contains_set_posechain(s: Ptr, pc: Ptr): boolean {
+	const _r = call<number>('contains_set_posechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pc)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function intersection_posechain_set(pc: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('intersection_posechain_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pc), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function intersection_set_posechain(s: Ptr, pc: Ptr): Ptr {
+	const _r = callPtr('intersection_set_posechain_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pc)]);
+	checkMeosError();
+	return _r;
+}
+
+export function minus_posechain_set(pc: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('minus_posechain_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pc), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function minus_set_posechain(s: Ptr, pc: Ptr): Ptr {
+	const _r = callPtr('minus_set_posechain_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pc)]);
+	checkMeosError();
+	return _r;
+}
+
+export function posechain_union_transfn(state: Ptr, pc: Ptr): Ptr {
+	const _r = callPtr('posechain_union_transfn_w', [ptrArgType(), ptrArgType()], [ptrArgVal(state), ptrArgVal(pc)]);
+	checkMeosError();
+	return _r;
+}
+
+export function union_posechain_set(pc: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('union_posechain_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pc), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function union_set_posechain(s: Ptr, pc: Ptr): Ptr {
+	const _r = callPtr('union_set_posechain_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pc)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tposechain_in(str: string): Ptr {
+	const _r = callPtr('tposechain_in_w', ['string'], [str]);
+	checkMeosError();
+	return _r;
+}
+
+export function tposechain_from_mfjson(mfjson: string): Ptr {
+	const _r = callPtr('tposechain_from_mfjson_w', ['string'], [mfjson]);
+	checkMeosError();
+	return _r;
+}
+
+export function tposechain_from_base_temp(pc: Ptr, temp: Ptr): Ptr {
+	const _r = callPtr('tposechain_from_base_temp_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pc), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tposechain_to_tpose(temp: Ptr): Ptr {
+	const _r = callPtr('tposechain_to_tpose_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tposechain_num_poses(temp: Ptr): number {
+	const _r = call<number>('tposechain_num_poses_w', 'number', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_eq_posechain_tposechain(posechain: Ptr, temp: Ptr): number {
+	const _r = call<number>('always_eq_posechain_tposechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(posechain), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_eq_tposechain_posechain(temp: Ptr, posechain: Ptr): number {
+	const _r = call<number>('always_eq_tposechain_posechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(posechain)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_eq_tposechain_tposechain(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('always_eq_tposechain_tposechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_ne_posechain_tposechain(posechain: Ptr, temp: Ptr): number {
+	const _r = call<number>('always_ne_posechain_tposechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(posechain), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_ne_tposechain_posechain(temp: Ptr, posechain: Ptr): number {
+	const _r = call<number>('always_ne_tposechain_posechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(posechain)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_ne_tposechain_tposechain(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('always_ne_tposechain_tposechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_eq_posechain_tposechain(posechain: Ptr, temp: Ptr): number {
+	const _r = call<number>('ever_eq_posechain_tposechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(posechain), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_eq_tposechain_posechain(temp: Ptr, posechain: Ptr): number {
+	const _r = call<number>('ever_eq_tposechain_posechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(posechain)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_eq_tposechain_tposechain(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('ever_eq_tposechain_tposechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_ne_posechain_tposechain(posechain: Ptr, temp: Ptr): number {
+	const _r = call<number>('ever_ne_posechain_tposechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(posechain), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_ne_tposechain_posechain(temp: Ptr, posechain: Ptr): number {
+	const _r = call<number>('ever_ne_tposechain_posechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(posechain)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_ne_tposechain_tposechain(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('ever_ne_tposechain_tposechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function teq_posechain_tposechain(posechain: Ptr, temp: Ptr): Ptr {
+	const _r = callPtr('teq_posechain_tposechain_w', [ptrArgType(), ptrArgType()], [ptrArgVal(posechain), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function teq_tposechain_posechain(temp: Ptr, posechain: Ptr): Ptr {
+	const _r = callPtr('teq_tposechain_posechain_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(posechain)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tne_posechain_tposechain(posechain: Ptr, temp: Ptr): Ptr {
+	const _r = callPtr('tne_posechain_tposechain_w', [ptrArgType(), ptrArgType()], [ptrArgVal(posechain), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tne_tposechain_posechain(temp: Ptr, posechain: Ptr): Ptr {
+	const _r = callPtr('tne_tposechain_posechain_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(posechain)]);
+	checkMeosError();
+	return _r;
+}
+
+
+// === meos_quadbin.h ===
+
+export function quadbin_in(str: string): number {
+	const _r = Number(call<bigint>('quadbin_in_w', 'bigint', ['string'], [str]));
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_eq(a: number, b: number): boolean {
+	const _r = call<number>('quadbin_eq_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_ne(a: number, b: number): boolean {
+	const _r = call<number>('quadbin_ne_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_lt(a: number, b: number): boolean {
+	const _r = call<number>('quadbin_lt_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_le(a: number, b: number): boolean {
+	const _r = call<number>('quadbin_le_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_gt(a: number, b: number): boolean {
+	const _r = call<number>('quadbin_gt_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_ge(a: number, b: number): boolean {
+	const _r = call<number>('quadbin_ge_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_cmp(a: number, b: number): number {
+	const _r = call<number>('quadbin_cmp_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]);
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_hash(cell: number): number {
+	const _r = call<number>('quadbin_hash_w', 'number', ['bigint'], [BigInt(cell)]);
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_hash_extended(cell: number, seed: number): number {
+	const _r = Number(call<bigint>('quadbin_hash_extended_w', 'bigint', ['bigint', 'bigint'], [BigInt(cell), BigInt(seed)]));
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_is_valid_index(index: number): boolean {
+	const _r = call<number>('quadbin_is_valid_index_w', 'number', ['bigint'], [BigInt(index)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_is_valid_cell(cell: number): boolean {
+	const _r = call<number>('quadbin_is_valid_cell_w', 'number', ['bigint'], [BigInt(cell)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_tile_to_cell(x: number, y: number, z: number): number {
+	const _r = Number(call<bigint>('quadbin_tile_to_cell_w', 'bigint', ['number', 'number', 'number'], [x, y, z]));
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_cell_to_tile(cell: number, x: Ptr, y: Ptr, z: Ptr): boolean {
+	const _r = call<number>('quadbin_cell_to_tile_w', 'number', ['bigint', ptrArgType(), ptrArgType(), ptrArgType()], [BigInt(cell), ptrArgVal(x), ptrArgVal(y), ptrArgVal(z)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_get_resolution(cell: number): number {
+	const _r = call<number>('quadbin_get_resolution_w', 'number', ['bigint'], [BigInt(cell)]);
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_cell_to_parent(cell: number, parent_resolution: number): number {
+	const _r = Number(call<bigint>('quadbin_cell_to_parent_w', 'bigint', ['bigint', 'number'], [BigInt(cell), parent_resolution]));
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_cell_to_children(cell: number, children_resolution: number, count: Ptr): Ptr {
+	const _r = callPtr('quadbin_cell_to_children_w', ['bigint', 'number', ptrArgType()], [BigInt(cell), children_resolution, ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_cell_sibling(cell: number, direction: string): number {
+	const _r = Number(call<bigint>('quadbin_cell_sibling_w', 'bigint', ['bigint', 'string'], [BigInt(cell), direction]));
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_k_ring(cell: number, k: number, count: Ptr): Ptr {
+	const _r = callPtr('quadbin_k_ring_w', ['bigint', 'number', ptrArgType()], [BigInt(cell), k, ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_point_to_cell(longitude: number, latitude: number, resolution: number): number {
+	const _r = Number(call<bigint>('quadbin_point_to_cell_w', 'bigint', ['number', 'number', 'number'], [longitude, latitude, resolution]));
+	checkMeosError();
+	return _r;
+}
+
+export function geo_to_quadbin_cell(point: Ptr, resolution: number): number {
+	const _r = Number(call<bigint>('geo_to_quadbin_cell_w', 'bigint', [ptrArgType(), 'number'], [ptrArgVal(point), resolution]));
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_cell_to_geompoint(cell: number): Ptr {
+	const _r = callPtr('quadbin_cell_to_geompoint_w', ['bigint'], [BigInt(cell)]);
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_cell_to_geom(cell: number): Ptr {
+	const _r = callPtr('quadbin_cell_to_geom_w', ['bigint'], [BigInt(cell)]);
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_to_stbox(cell: number): Ptr {
+	const _r = callPtr('quadbin_to_stbox_w', ['bigint'], [BigInt(cell)]);
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_timestamptz_to_stbox(cell: number, t: TimestampTz): Ptr {
+	const _r = callPtr('quadbin_timestamptz_to_stbox_w', ['bigint', 'bigint'], [BigInt(cell), BigInt(t)]);
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_tstzspan_to_stbox(cell: number, s: Ptr): Ptr {
+	const _r = callPtr('quadbin_tstzspan_to_stbox_w', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_cell_area(cell: number): number {
+	const _r = call<number>('quadbin_cell_area_w', 'number', ['bigint'], [BigInt(cell)]);
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_index_to_string(index: number): string {
+	const _r = call<string>('quadbin_index_to_string_w', 'string', ['bigint'], [BigInt(index)]);
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_string_to_index(str: string): number {
+	const _r = Number(call<bigint>('quadbin_string_to_index_w', 'bigint', ['string'], [str]));
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_cell_to_quadkey(cell: number): string {
+	const _r = call<string>('quadbin_cell_to_quadkey_w', 'string', ['bigint'], [BigInt(cell)]);
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_grid_disk(origin: number, k: number): Ptr {
+	const _r = callPtr('quadbin_grid_disk_w', ['bigint', 'number'], [BigInt(origin), k]);
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_cell_to_children_set(origin: number, children_resolution: number): Ptr {
+	const _r = callPtr('quadbin_cell_to_children_set_w', ['bigint', 'number'], [BigInt(origin), children_resolution]);
+	checkMeosError();
+	return _r;
+}
+
+export function tquadbin_in(str: string): Ptr {
+	const _r = callPtr('tquadbin_in_w', ['string'], [str]);
+	checkMeosError();
+	return _r;
+}
+
+export function tquadbin_make(value: number, t: TimestampTz): Ptr {
+	const _r = callPtr('tquadbin_make_w', ['bigint', 'bigint'], [BigInt(value), BigInt(t)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tquadbininst_make(value: number, t: TimestampTz): Ptr {
+	const _r = callPtr('tquadbininst_make_w', ['bigint', 'bigint'], [BigInt(value), BigInt(t)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tquadbinseq_make(values: Ptr, times: Ptr, count: number, lower_inc: boolean, upper_inc: boolean): Ptr {
+	const _r = callPtr('tquadbinseq_make_w', [ptrArgType(), ptrArgType(), 'number', 'number', 'number'], [ptrArgVal(values), ptrArgVal(times), count, lower_inc ? 1 : 0, upper_inc ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function tquadbinseqset_make(sequences: Ptr, count: number): Ptr {
+	const _r = callPtr('tquadbinseqset_make_w', [ptrArgType(), 'number'], [ptrArgVal(sequences), count]);
+	checkMeosError();
+	return _r;
+}
+
+export function tquadbin_start_value(temp: Ptr): number {
+	const _r = Number(call<bigint>('tquadbin_start_value_w', 'bigint', [ptrArgType()], [ptrArgVal(temp)]));
+	checkMeosError();
+	return _r;
+}
+
+export function tquadbin_end_value(temp: Ptr): number {
+	const _r = Number(call<bigint>('tquadbin_end_value_w', 'bigint', [ptrArgType()], [ptrArgVal(temp)]));
+	checkMeosError();
+	return _r;
+}
+
+export function tquadbin_value_n(temp: Ptr, n: number): number {
+	const _r = Number(call<bigint>('tquadbin_value_n_w', 'bigint', [ptrArgType(), 'number'], [ptrArgVal(temp), n]));
+	checkMeosError();
+	return _r;
+}
+
+export function tquadbin_values(temp: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('tquadbin_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tquadbin_value_at_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): number {
+	const _r = Number(call<bigint>('tquadbin_value_at_timestamptz_w', 'bigint', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0]));
+	checkMeosError();
+	return _r;
+}
+
+export function quadbin_to_set(cell: number): Ptr {
+	const _r = callPtr('quadbin_to_set_w', ['bigint'], [BigInt(cell)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tbigint_to_tquadbin(temp: Ptr): Ptr {
+	const _r = callPtr('tbigint_to_tquadbin_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tquadbin_to_tbigint(temp: Ptr): Ptr {
+	const _r = callPtr('tquadbin_to_tbigint_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_eq_quadbin_tquadbin(cell: number, temp: Ptr): number {
+	const _r = call<number>('ever_eq_quadbin_tquadbin_w', 'number', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_eq_tquadbin_quadbin(temp: Ptr, cell: number): number {
+	const _r = call<number>('ever_eq_tquadbin_quadbin_w', 'number', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_ne_quadbin_tquadbin(cell: number, temp: Ptr): number {
+	const _r = call<number>('ever_ne_quadbin_tquadbin_w', 'number', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_ne_tquadbin_quadbin(temp: Ptr, cell: number): number {
+	const _r = call<number>('ever_ne_tquadbin_quadbin_w', 'number', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_eq_quadbin_tquadbin(cell: number, temp: Ptr): number {
+	const _r = call<number>('always_eq_quadbin_tquadbin_w', 'number', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_eq_tquadbin_quadbin(temp: Ptr, cell: number): number {
+	const _r = call<number>('always_eq_tquadbin_quadbin_w', 'number', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_ne_quadbin_tquadbin(cell: number, temp: Ptr): number {
+	const _r = call<number>('always_ne_quadbin_tquadbin_w', 'number', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_ne_tquadbin_quadbin(temp: Ptr, cell: number): number {
+	const _r = call<number>('always_ne_tquadbin_quadbin_w', 'number', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_eq_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('ever_eq_tquadbin_tquadbin_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_ne_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('ever_ne_tquadbin_tquadbin_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_eq_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('always_eq_tquadbin_tquadbin_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_ne_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('always_ne_tquadbin_tquadbin_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function teq_quadbin_tquadbin(cell: number, temp: Ptr): Ptr {
+	const _r = callPtr('teq_quadbin_tquadbin_w', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function teq_tquadbin_quadbin(temp: Ptr, cell: number): Ptr {
+	const _r = callPtr('teq_tquadbin_quadbin_w', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]);
+	checkMeosError();
+	return _r;
+}
+
+export function teq_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): Ptr {
+	const _r = callPtr('teq_tquadbin_tquadbin_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tne_quadbin_tquadbin(cell: number, temp: Ptr): Ptr {
+	const _r = callPtr('tne_quadbin_tquadbin_w', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tne_tquadbin_quadbin(temp: Ptr, cell: number): Ptr {
+	const _r = callPtr('tne_tquadbin_quadbin_w', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tne_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): Ptr {
+	const _r = callPtr('tne_tquadbin_tquadbin_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tquadbin_cell_to_quadkey(temp: Ptr): Ptr {
+	const _r = callPtr('tquadbin_cell_to_quadkey_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+
+// === meos_raster.h ===
+
+export function raquet_pixtype_size(pixtype: number): number {
+	const _r = call<number>('raquet_pixtype_size_w', 'number', ['number'], [pixtype]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_pixtype_from_string(str: string): number {
+	const _r = call<number>('raquet_pixtype_from_string_w', 'number', ['string'], [str]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_in(str: string): Ptr {
+	const _r = callPtr('raquet_in_w', ['string'], [str]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_out(rq: Ptr): string {
+	const _r = call<string>('raquet_out_w', 'string', [ptrArgType()], [ptrArgVal(rq)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_from_wkb(wkb: Ptr, size: number): Ptr {
+	const _r = callPtr('raquet_from_wkb_w', [ptrArgType(), 'number'], [ptrArgVal(wkb), size]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_from_hexwkb(hexwkb: string): Ptr {
+	const _r = callPtr('raquet_from_hexwkb_w', ['string'], [hexwkb]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_as_wkb(rq: Ptr, variant: number, size_out: Ptr): Ptr {
+	const _r = callPtr('raquet_as_wkb_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(rq), variant, ptrArgVal(size_out)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_as_hexwkb(rq: Ptr, variant: number, size_out: Ptr): string {
+	const _r = call<string>('raquet_as_hexwkb_w', 'string', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(rq), variant, ptrArgVal(size_out)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_make(quadbin: number, width: number, height: number, pixtype: number, nodata: number, has_nodata: boolean, pixels: Ptr, pixels_size: number): Ptr {
+	const _r = callPtr('raquet_make_w', ['bigint', 'number', 'number', 'number', 'number', 'number', ptrArgType(), 'number'], [BigInt(quadbin), width, height, pixtype, nodata, has_nodata ? 1 : 0, ptrArgVal(pixels), pixels_size]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_copy(rq: Ptr): Ptr {
+	const _r = callPtr('raquet_copy_w', [ptrArgType()], [ptrArgVal(rq)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_read(path: string, quadbin: number): Ptr {
+	const _r = callPtr('raquet_read_w', ['string', 'bigint'], [path, BigInt(quadbin)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_read_bytes(data: Ptr, size: number, quadbin: number): Ptr {
+	const _r = callPtr('raquet_read_bytes_w', [ptrArgType(), 'number', 'bigint'], [ptrArgVal(data), size, BigInt(quadbin)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_quadbin(rq: Ptr): number {
+	const _r = Number(call<bigint>('raquet_quadbin_w', 'bigint', [ptrArgType()], [ptrArgVal(rq)]));
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_width(rq: Ptr): number {
+	const _r = call<number>('raquet_width_w', 'number', [ptrArgType()], [ptrArgVal(rq)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_height(rq: Ptr): number {
+	const _r = call<number>('raquet_height_w', 'number', [ptrArgType()], [ptrArgVal(rq)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_nodata(rq: Ptr): number {
+	const _r = call<number>('raquet_nodata_w', 'number', [ptrArgType()], [ptrArgVal(rq)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_pixtype(rq: Ptr): string {
+	const _r = call<string>('raquet_pixtype_w', 'string', [ptrArgType()], [ptrArgVal(rq)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_pixels(rq: Ptr, size_out: Ptr): Ptr {
+	const _r = callPtr('raquet_pixels_w', [ptrArgType(), ptrArgType()], [ptrArgVal(rq), ptrArgVal(size_out)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_hash(rq: Ptr): number {
+	const _r = call<number>('raquet_hash_w', 'number', [ptrArgType()], [ptrArgVal(rq)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_hash_extended(rq: Ptr, seed: number): number {
+	const _r = Number(call<bigint>('raquet_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(rq), BigInt(seed)]));
+	checkMeosError();
+	return _r;
+}
+
+export function raster_from_wkb(wkb: Ptr, size: number): Ptr {
+	const _r = callPtr('raster_from_wkb_w', [ptrArgType(), 'number'], [ptrArgVal(wkb), size]);
+	checkMeosError();
+	return _r;
+}
+
+export function raster_from_hexwkb(hexwkb: string): Ptr {
+	const _r = callPtr('raster_from_hexwkb_w', ['string'], [hexwkb]);
+	checkMeosError();
+	return _r;
+}
+
+export function raster_as_wkb(rast: Ptr, size_out: Ptr): Ptr {
+	const _r = callPtr('raster_as_wkb_w', [ptrArgType(), ptrArgType()], [ptrArgVal(rast), ptrArgVal(size_out)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raster_as_hexwkb(rast: Ptr, size_out: Ptr): string {
+	const _r = call<string>('raster_as_hexwkb_w', 'string', [ptrArgType(), ptrArgType()], [ptrArgVal(rast), ptrArgVal(size_out)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raster_num_bands(rast: Ptr): number {
+	const _r = call<number>('raster_num_bands_w', 'number', [ptrArgType()], [ptrArgVal(rast)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_to_stbox(rq: Ptr): Ptr {
+	const _r = callPtr('raquet_to_stbox_w', [ptrArgType()], [ptrArgVal(rq)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_cmp(rq1: Ptr, rq2: Ptr): number {
+	const _r = call<number>('raquet_cmp_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(rq1), ptrArgVal(rq2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_eq(rq1: Ptr, rq2: Ptr): boolean {
+	const _r = call<number>('raquet_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(rq1), ptrArgVal(rq2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_ne(rq1: Ptr, rq2: Ptr): boolean {
+	const _r = call<number>('raquet_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(rq1), ptrArgVal(rq2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_lt(rq1: Ptr, rq2: Ptr): boolean {
+	const _r = call<number>('raquet_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(rq1), ptrArgVal(rq2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_le(rq1: Ptr, rq2: Ptr): boolean {
+	const _r = call<number>('raquet_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(rq1), ptrArgVal(rq2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_ge(rq1: Ptr, rq2: Ptr): boolean {
+	const _r = call<number>('raquet_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(rq1), ptrArgVal(rq2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function raquet_gt(rq1: Ptr, rq2: Ptr): boolean {
+	const _r = call<number>('raquet_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(rq1), ptrArgVal(rq2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function raster_value(traj: Ptr, box: Ptr, sample: number, ctx: Ptr): Ptr {
+	const _r = callPtr('raster_value_w', [ptrArgType(), ptrArgType(), 'number', ptrArgType()], [ptrArgVal(traj), ptrArgVal(box), sample, ptrArgVal(ctx)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raster_at_value(traj: Ptr, box: Ptr, sample: number, ctx: Ptr, vspan: Ptr): Ptr {
+	const _r = callPtr('raster_at_value_w', [ptrArgType(), ptrArgType(), 'number', ptrArgType(), ptrArgType()], [ptrArgVal(traj), ptrArgVal(box), sample, ptrArgVal(ctx), ptrArgVal(vspan)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raster_minus_value(traj: Ptr, box: Ptr, sample: number, ctx: Ptr, vspan: Ptr): Ptr {
+	const _r = callPtr('raster_minus_value_w', [ptrArgType(), ptrArgType(), 'number', ptrArgType(), ptrArgType()], [ptrArgVal(traj), ptrArgVal(box), sample, ptrArgVal(ctx), ptrArgVal(vspan)]);
+	checkMeosError();
+	return _r;
+}
+
+export function eraster_value(traj: Ptr, box: Ptr, sample: number, ctx: Ptr, vspan: Ptr): number {
+	const _r = call<number>('eraster_value_w', 'number', [ptrArgType(), ptrArgType(), 'number', ptrArgType(), ptrArgType()], [ptrArgVal(traj), ptrArgVal(box), sample, ptrArgVal(ctx), ptrArgVal(vspan)]);
+	checkMeosError();
+	return _r;
+}
+
+export function araster_value(traj: Ptr, box: Ptr, sample: number, ctx: Ptr, vspan: Ptr): number {
+	const _r = call<number>('araster_value_w', 'number', [ptrArgType(), ptrArgType(), 'number', ptrArgType(), ptrArgType()], [ptrArgVal(traj), ptrArgVal(box), sample, ptrArgVal(ctx), ptrArgVal(vspan)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raster_value_gdal(traj: Ptr, path: string, band: number): Ptr {
+	const _r = callPtr('raster_value_gdal_w', [ptrArgType(), 'string', 'number'], [ptrArgVal(traj), path, band]);
+	checkMeosError();
+	return _r;
+}
+
+export function raster_at_value_gdal(traj: Ptr, path: string, band: number, vspan: Ptr): Ptr {
+	const _r = callPtr('raster_at_value_gdal_w', [ptrArgType(), 'string', 'number', ptrArgType()], [ptrArgVal(traj), path, band, ptrArgVal(vspan)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raster_minus_value_gdal(traj: Ptr, path: string, band: number, vspan: Ptr): Ptr {
+	const _r = callPtr('raster_minus_value_gdal_w', [ptrArgType(), 'string', 'number', ptrArgType()], [ptrArgVal(traj), path, band, ptrArgVal(vspan)]);
+	checkMeosError();
+	return _r;
+}
+
+export function eraster_value_gdal(traj: Ptr, path: string, band: number, vspan: Ptr): number {
+	const _r = call<number>('eraster_value_gdal_w', 'number', [ptrArgType(), 'string', 'number', ptrArgType()], [ptrArgVal(traj), path, band, ptrArgVal(vspan)]);
+	checkMeosError();
+	return _r;
+}
+
+export function araster_value_gdal(traj: Ptr, path: string, band: number, vspan: Ptr): number {
+	const _r = call<number>('araster_value_gdal_w', 'number', [ptrArgType(), 'string', 'number', ptrArgType()], [ptrArgVal(traj), path, band, ptrArgVal(vspan)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raster_tile_value_quadbin(traj: Ptr, pixels: Ptr, pixels_size: number, width: number, height: number, quadbin: number, pixtype: number, nodata: number, has_nodata: boolean): Ptr {
+	const _r = callPtr('raster_tile_value_quadbin_w', [ptrArgType(), ptrArgType(), 'number', 'number', 'number', 'bigint', 'number', 'number', 'number'], [ptrArgVal(traj), ptrArgVal(pixels), pixels_size, width, height, BigInt(quadbin), pixtype, nodata, has_nodata ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function raster_tile_value(traj: Ptr, rq: Ptr): Ptr {
+	const _r = callPtr('raster_tile_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(traj), ptrArgVal(rq)]);
+	checkMeosError();
+	return _r;
+}
+
+export function raster_tile_value_array(traj: Ptr, rqarr: Ptr, count: number): Ptr {
+	const _r = callPtr('raster_tile_value_array_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(traj), ptrArgVal(rqarr), count]);
+	checkMeosError();
+	return _r;
+}
+
+export function trajectory_quadbins(traj: Ptr, zoom: number, count: Ptr): Ptr {
+	const _r = callPtr('trajectory_quadbins_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(traj), zoom, ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+
+// === meos_rgeo.h ===
+
+export function trgeometry_in(str: string): Ptr {
+	const _r = callPtr('trgeometry_in_w', ['string'], [str]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_from_mfjson(mfjson: string): Ptr {
+	const _r = callPtr('trgeometry_from_mfjson_w', ['string'], [mfjson]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_out(temp: Ptr): string {
+	const _r = call<string>('trgeometry_out_w', 'string', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_as_text(temp: Ptr, maxdd: number): string {
+	const _r = call<string>('trgeometry_as_text_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(temp), maxdd]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_as_ewkt(temp: Ptr, maxdd: number): string {
+	const _r = call<string>('trgeometry_as_ewkt_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(temp), maxdd]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometryinst_make(geom: Ptr, pose: Ptr, t: TimestampTz): Ptr {
+	const _r = callPtr('trgeometryinst_make_w', [ptrArgType(), ptrArgType(), 'bigint'], [ptrArgVal(geom), ptrArgVal(pose), BigInt(t)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometryseq_make(geom: Ptr, instants: Ptr, count: number, lower_inc: boolean, upper_inc: boolean, interp: number, normalize: boolean): Ptr {
+	const _r = callPtr('trgeometryseq_make_w', [ptrArgType(), ptrArgType(), 'number', 'number', 'number', 'number', 'number'], [ptrArgVal(geom), ptrArgVal(instants), count, lower_inc ? 1 : 0, upper_inc ? 1 : 0, interp, normalize ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometryseqset_make(geom: Ptr, sequences: Ptr, count: number, normalize: boolean): Ptr {
+	const _r = callPtr('trgeometryseqset_make_w', [ptrArgType(), ptrArgType(), 'number', 'number'], [ptrArgVal(geom), ptrArgVal(sequences), count, normalize ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometryseqset_make_gaps(geom: Ptr, instants: Ptr, count: number, interp: number, maxt: Ptr, maxdist: number): Ptr {
+	const _r = callPtr('trgeometryseqset_make_gaps_w', [ptrArgType(), ptrArgType(), 'number', 'number', ptrArgType(), 'number'], [ptrArgVal(geom), ptrArgVal(instants), count, interp, ptrArgVal(maxt), maxdist]);
+	checkMeosError();
+	return _r;
+}
+
+export function geometry_tpose_to_trgeometry(gs: Ptr, temp: Ptr): Ptr {
+	const _r = callPtr('geometry_tpose_to_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_to_tpose(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_to_tpose_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_to_tgeompoint(temp: Ptr): Ptr {
 	const _r = callPtr('trgeometry_to_tgeompoint_w', [ptrArgType()], [ptrArgVal(temp)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_to_tgeometry(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_to_tgeometry_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function trgeometry_to_tgeometry(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_to_tgeometry_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_end_instant(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_end_instant_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_end_sequence(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_end_sequence_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_end_value(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_end_value_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_geom(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_geom_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_instant_n(temp: Ptr, n: number): Ptr {
+	const _r = callPtr('trgeometry_instant_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), n]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_instants(temp: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('trgeometry_instants_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_points(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_points_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_yaw(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_yaw_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_pitch(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_pitch_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_roll(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_roll_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_segments(temp: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('trgeometry_segments_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_sequence_n(temp: Ptr, i: number): Ptr {
+	const _r = callPtr('trgeometry_sequence_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), i]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_sequences(temp: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('trgeometry_sequences_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_start_instant(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_start_instant_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_start_sequence(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_start_sequence_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_start_value(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_start_value_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_value_n(temp: Ptr, n: number): Ptr {
+	const _r = callPtr('trgeometry_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), n]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_traversed_area(temp: Ptr, unary_union: boolean): Ptr {
+	const _r = callPtr('trgeometry_traversed_area_w', [ptrArgType(), 'number'], [ptrArgVal(temp), unary_union ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_centroid(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_centroid_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_convex_hull(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_convex_hull_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_body_point_trajectory(temp: Ptr, gs: Ptr): Ptr {
+	const _r = callPtr('trgeometry_body_point_trajectory_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_space_boxes(temp: Ptr, xsize: number, ysize: number, zsize: number, sorigin: Ptr, bitmatrix: boolean, border_inc: boolean, count: Ptr): Ptr {
+	const _r = callPtr('trgeometry_space_boxes_w', [ptrArgType(), 'number', 'number', 'number', ptrArgType(), 'number', 'number', ptrArgType()], [ptrArgVal(temp), xsize, ysize, zsize, ptrArgVal(sorigin), bitmatrix ? 1 : 0, border_inc ? 1 : 0, ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_space_time_boxes(temp: Ptr, xsize: number, ysize: number, zsize: number, duration: Ptr, sorigin: Ptr, torigin: TimestampTz, bitmatrix: boolean, border_inc: boolean, count: Ptr): Ptr {
+	const _r = callPtr('trgeometry_space_time_boxes_w', [ptrArgType(), 'number', 'number', 'number', ptrArgType(), ptrArgType(), 'bigint', 'number', 'number', ptrArgType()], [ptrArgVal(temp), xsize, ysize, zsize, ptrArgVal(duration), ptrArgVal(sorigin), BigInt(torigin), bitmatrix ? 1 : 0, border_inc ? 1 : 0, ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_stboxes(temp: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('trgeometry_stboxes_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_split_n_stboxes(temp: Ptr, box_count: number, count: Ptr): Ptr {
+	const _r = callPtr('trgeometry_split_n_stboxes_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(temp), box_count, ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_split_each_n_stboxes(temp: Ptr, elem_count: number, count: Ptr): Ptr {
+	const _r = callPtr('trgeometry_split_each_n_stboxes_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(temp), elem_count, ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_hausdorff_distance(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('trgeometry_hausdorff_distance_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_frechet_distance(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('trgeometry_frechet_distance_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_dyntimewarp_distance(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('trgeometry_dyntimewarp_distance_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_frechet_path(temp1: Ptr, temp2: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('trgeometry_frechet_path_w', [ptrArgType(), ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2), ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_dyntimewarp_path(temp1: Ptr, temp2: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('trgeometry_dyntimewarp_path_w', [ptrArgType(), ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2), ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_length(temp: Ptr): number {
+	const _r = call<number>('trgeometry_length_w', 'number', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_cumulative_length(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_cumulative_length_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_angular_speed(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_angular_speed_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_speed(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_speed_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_twcentroid(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_twcentroid_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_append_tinstant(temp: Ptr, inst: Ptr, interp: number, maxdist: number, maxt: Ptr, expand: boolean): Ptr {
+	const _r = callPtr('trgeometry_append_tinstant_w', [ptrArgType(), ptrArgType(), 'number', 'number', ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(inst), interp, maxdist, ptrArgVal(maxt), expand ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_append_tsequence(temp: Ptr, seq: Ptr, expand: boolean): Ptr {
+	const _r = callPtr('trgeometry_append_tsequence_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(seq), expand ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_delete_timestamptz(temp: Ptr, t: TimestampTz, connect: boolean): Ptr {
+	const _r = callPtr('trgeometry_delete_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), connect ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_delete_tstzset(temp: Ptr, s: Ptr, connect: boolean): Ptr {
+	const _r = callPtr('trgeometry_delete_tstzset_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(s), connect ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_delete_tstzspan(temp: Ptr, s: Ptr, connect: boolean): Ptr {
+	const _r = callPtr('trgeometry_delete_tstzspan_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(s), connect ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_delete_tstzspanset(temp: Ptr, ss: Ptr, connect: boolean): Ptr {
+	const _r = callPtr('trgeometry_delete_tstzspanset_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(ss), connect ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_merge(temp1: Ptr, temp2: Ptr): Ptr {
+	const _r = callPtr('trgeometry_merge_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_merge_array(temparr: Ptr, count: number): Ptr {
+	const _r = callPtr('trgeometry_merge_array_w', [ptrArgType(), 'number'], [ptrArgVal(temparr), count]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_round(temp: Ptr, maxdd: number): Ptr {
+	const _r = callPtr('trgeometry_round_w', [ptrArgType(), 'number'], [ptrArgVal(temp), maxdd]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_set_interp(temp: Ptr, interp: number): Ptr {
+	const _r = callPtr('trgeometry_set_interp_w', [ptrArgType(), 'number'], [ptrArgVal(temp), interp]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_as_tinstant(temp: Ptr): Ptr {
+	const _r = callPtr('trgeometry_as_tinstant_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_as_tsequence(temp: Ptr, interp_str: string): Ptr {
+	const _r = callPtr('trgeometry_as_tsequence_w', [ptrArgType(), 'string'], [ptrArgVal(temp), interp_str]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_as_tsequenceset(temp: Ptr, interp_str: string): Ptr {
+	const _r = callPtr('trgeometry_as_tsequenceset_w', [ptrArgType(), 'string'], [ptrArgVal(temp), interp_str]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_after_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): Ptr {
+	const _r = callPtr('trgeometry_after_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_before_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): Ptr {
+	const _r = callPtr('trgeometry_before_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_at_geom(temp: Ptr, gs: Ptr): Ptr {
+	const _r = callPtr('trgeometry_at_geom_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_minus_geom(temp: Ptr, gs: Ptr): Ptr {
+	const _r = callPtr('trgeometry_minus_geom_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_at_stbox(temp: Ptr, box: Ptr, border_inc: boolean): Ptr {
+	const _r = callPtr('trgeometry_at_stbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(box), border_inc ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_minus_stbox(temp: Ptr, box: Ptr, border_inc: boolean): Ptr {
+	const _r = callPtr('trgeometry_minus_stbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(box), border_inc ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_at_value(temp: Ptr, pose: Ptr): Ptr {
+	const _r = callPtr('trgeometry_at_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_minus_value(temp: Ptr, pose: Ptr): Ptr {
+	const _r = callPtr('trgeometry_minus_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_at_values(temp: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('trgeometry_at_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_minus_values(temp: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('trgeometry_minus_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_at_timestamptz(temp: Ptr, t: TimestampTz): Ptr {
+	const _r = callPtr('trgeometry_at_timestamptz_w', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(t)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_minus_timestamptz(temp: Ptr, t: TimestampTz): Ptr {
+	const _r = callPtr('trgeometry_minus_timestamptz_w', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(t)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_at_tstzset(temp: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('trgeometry_at_tstzset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_minus_tstzset(temp: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('trgeometry_minus_tstzset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_at_tstzspan(temp: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('trgeometry_at_tstzspan_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_minus_tstzspan(temp: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('trgeometry_minus_tstzspan_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_at_tstzspanset(temp: Ptr, ss: Ptr): Ptr {
+	const _r = callPtr('trgeometry_at_tstzspanset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(ss)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_minus_tstzspanset(temp: Ptr, ss: Ptr): Ptr {
+	const _r = callPtr('trgeometry_minus_tstzspanset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(ss)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_at_elevation(temp: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('trgeometry_at_elevation_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function trgeometry_minus_elevation(temp: Ptr, s: Ptr): Ptr {
+	const _r = callPtr('trgeometry_minus_elevation_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tdistance_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr {
+	const _r = callPtr('tdistance_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tdistance_trgeometry_tpoint(temp1: Ptr, temp2: Ptr): Ptr {
+	const _r = callPtr('tdistance_trgeometry_tpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tdistance_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): Ptr {
+	const _r = callPtr('tdistance_trgeometry_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function nad_stbox_trgeometry(box: Ptr, temp: Ptr): number {
+	const _r = call<number>('nad_stbox_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function nad_trgeometry_geo(temp: Ptr, gs: Ptr): number {
+	const _r = call<number>('nad_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function nad_trgeometry_stbox(temp: Ptr, box: Ptr): number {
+	const _r = call<number>('nad_trgeometry_stbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]);
+	checkMeosError();
+	return _r;
+}
+
+export function nad_trgeometry_tpoint(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('nad_trgeometry_tpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function nad_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('nad_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function nai_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr {
+	const _r = callPtr('nai_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function nai_trgeometry_tpoint(temp1: Ptr, temp2: Ptr): Ptr {
+	const _r = callPtr('nai_trgeometry_tpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function nai_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): Ptr {
+	const _r = callPtr('nai_trgeometry_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function shortestline_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr {
+	const _r = callPtr('shortestline_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function shortestline_trgeometry_tpoint(temp1: Ptr, temp2: Ptr): Ptr {
+	const _r = callPtr('shortestline_trgeometry_tpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function shortestline_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): Ptr {
+	const _r = callPtr('shortestline_trgeometry_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_eq_geo_trgeometry(gs: Ptr, temp: Ptr): number {
+	const _r = call<number>('always_eq_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_eq_trgeometry_geo(temp: Ptr, gs: Ptr): number {
+	const _r = call<number>('always_eq_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_eq_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('always_eq_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_ne_geo_trgeometry(gs: Ptr, temp: Ptr): number {
+	const _r = call<number>('always_ne_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_ne_trgeometry_geo(temp: Ptr, gs: Ptr): number {
+	const _r = call<number>('always_ne_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_ne_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('always_ne_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_eq_geo_trgeometry(gs: Ptr, temp: Ptr): number {
+	const _r = call<number>('ever_eq_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_eq_trgeometry_geo(temp: Ptr, gs: Ptr): number {
+	const _r = call<number>('ever_eq_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_eq_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('ever_eq_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_ne_geo_trgeometry(gs: Ptr, temp: Ptr): number {
+	const _r = call<number>('ever_ne_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_ne_trgeometry_geo(temp: Ptr, gs: Ptr): number {
+	const _r = call<number>('ever_ne_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_ne_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('ever_ne_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function teq_geo_trgeometry(gs: Ptr, temp: Ptr): Ptr {
+	const _r = callPtr('teq_geo_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function teq_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr {
+	const _r = callPtr('teq_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tne_geo_trgeometry(gs: Ptr, temp: Ptr): Ptr {
+	const _r = callPtr('tne_geo_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tne_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr {
+	const _r = callPtr('tne_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function econtains_geo_trgeometry(gs: Ptr, temp: Ptr): number {
+	const _r = call<number>('econtains_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function acontains_geo_trgeometry(gs: Ptr, temp: Ptr): number {
+	const _r = call<number>('acontains_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ecovers_geo_trgeometry(gs: Ptr, temp: Ptr): number {
+	const _r = call<number>('ecovers_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function acovers_geo_trgeometry(gs: Ptr, temp: Ptr): number {
+	const _r = call<number>('acovers_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ecovers_trgeometry_geo(temp: Ptr, gs: Ptr): number {
+	const _r = call<number>('ecovers_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function acovers_trgeometry_geo(temp: Ptr, gs: Ptr): number {
+	const _r = call<number>('acovers_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function edisjoint_trgeometry_geo(temp: Ptr, gs: Ptr): number {
+	const _r = call<number>('edisjoint_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function adisjoint_trgeometry_geo(temp: Ptr, gs: Ptr): number {
+	const _r = call<number>('adisjoint_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function eintersects_trgeometry_geo(temp: Ptr, gs: Ptr): number {
+	const _r = call<number>('eintersects_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function aintersects_trgeometry_geo(temp: Ptr, gs: Ptr): number {
+	const _r = call<number>('aintersects_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function etouches_trgeometry_geo(temp: Ptr, gs: Ptr): number {
+	const _r = call<number>('etouches_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function atouches_trgeometry_geo(temp: Ptr, gs: Ptr): number {
+	const _r = call<number>('atouches_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+	checkMeosError();
+	return _r;
+}
+
+export function edwithin_trgeometry_geo(temp: Ptr, gs: Ptr, dist: number): number {
+	const _r = call<number>('edwithin_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(gs), dist]);
+	checkMeosError();
+	return _r;
+}
+
+export function adwithin_trgeometry_geo(temp: Ptr, gs: Ptr, dist: number): number {
+	const _r = call<number>('adwithin_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(gs), dist]);
+	checkMeosError();
+	return _r;
+}
+
+export function edisjoint_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('edisjoint_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function adisjoint_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('adisjoint_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function eintersects_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('eintersects_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function aintersects_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('aintersects_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function edwithin_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr, dist: number): number {
+	const _r = call<number>('edwithin_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp1), ptrArgVal(temp2), dist]);
+	checkMeosError();
+	return _r;
+}
+
+export function adwithin_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr, dist: number): number {
+	const _r = call<number>('adwithin_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp1), ptrArgVal(temp2), dist]);
+	checkMeosError();
+	return _r;
+}
+
+
+// === meos_s2cell.h ===
+
+export function s2cell_in(str: string): number {
+	const _r = call<number>('s2cell_in_w', 'number', ['string'], [str]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_out(cell: number): string {
+	const _r = call<string>('s2cell_out_w', 'string', ['number'], [cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_eq(a: number, b: number): boolean {
+	const _r = call<number>('s2cell_eq_w', 'number', ['number', 'number'], [a, b]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_ne(a: number, b: number): boolean {
+	const _r = call<number>('s2cell_ne_w', 'number', ['number', 'number'], [a, b]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_lt(a: number, b: number): boolean {
+	const _r = call<number>('s2cell_lt_w', 'number', ['number', 'number'], [a, b]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_le(a: number, b: number): boolean {
+	const _r = call<number>('s2cell_le_w', 'number', ['number', 'number'], [a, b]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_gt(a: number, b: number): boolean {
+	const _r = call<number>('s2cell_gt_w', 'number', ['number', 'number'], [a, b]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_ge(a: number, b: number): boolean {
+	const _r = call<number>('s2cell_ge_w', 'number', ['number', 'number'], [a, b]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_cmp(a: number, b: number): number {
+	const _r = call<number>('s2cell_cmp_w', 'number', ['number', 'number'], [a, b]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_hash(cell: number): number {
+	const _r = call<number>('s2cell_hash_w', 'number', ['number'], [cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_hash_extended(cell: number, seed: number): number {
+	const _r = Number(call<bigint>('s2cell_hash_extended_w', 'bigint', ['number', 'bigint'], [cell, BigInt(seed)]));
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_is_valid_cell(cell: number): boolean {
+	const _r = call<number>('s2cell_is_valid_cell_w', 'number', ['number'], [cell]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_cell_to_token(cell: number): string {
+	const _r = call<string>('s2cell_cell_to_token_w', 'string', ['number'], [cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_token_to_cell(token: string): number {
+	const _r = call<number>('s2cell_token_to_cell_w', 'number', ['string'], [token]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_get_resolution(cell: number): number {
+	const _r = call<number>('s2cell_get_resolution_w', 'number', ['number'], [cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_get_face(cell: number): number {
+	const _r = call<number>('s2cell_get_face_w', 'number', ['number'], [cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_cell_to_parent(cell: number, level: number): number {
+	const _r = call<number>('s2cell_cell_to_parent_w', 'number', ['number', 'number'], [cell, level]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_cell_to_child(cell: number, level: number, position: number): number {
+	const _r = call<number>('s2cell_cell_to_child_w', 'number', ['number', 'number', 'number'], [cell, level, position]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_cell_to_children(cell: number, level: number, count: Ptr): Ptr {
+	const _r = callPtr('s2cell_cell_to_children_w', ['number', 'number', ptrArgType()], [cell, level, ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_cell_contains(cell: number, other: number): boolean {
+	const _r = call<number>('s2cell_cell_contains_w', 'number', ['number', 'number'], [cell, other]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_common_ancestor_level(a: number, b: number): number {
+	const _r = call<number>('s2cell_common_ancestor_level_w', 'number', ['number', 'number'], [a, b]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_range_min(cell: number): number {
+	const _r = call<number>('s2cell_range_min_w', 'number', ['number'], [cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_range_max(cell: number): number {
+	const _r = call<number>('s2cell_range_max_w', 'number', ['number'], [cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_edge_neighbors(cell: number, count: Ptr): Ptr {
+	const _r = callPtr('s2cell_edge_neighbors_w', ['number', ptrArgType()], [cell, ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_point_to_cell(longitude: number, latitude: number, level: number): number {
+	const _r = call<number>('s2cell_point_to_cell_w', 'number', ['number', 'number', 'number'], [longitude, latitude, level]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_cell_area(cell: number): number {
+	const _r = call<number>('s2cell_cell_area_w', 'number', ['number'], [cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_edge_length(cell: number, edge: number): number {
+	const _r = call<number>('s2cell_edge_length_w', 'number', ['number', 'number'], [cell, edge]);
+	checkMeosError();
+	return _r;
+}
+
+export function geo_to_s2cell_cell(point: Ptr, level: number): number {
+	const _r = call<number>('geo_to_s2cell_cell_w', 'number', [ptrArgType(), 'number'], [ptrArgVal(point), level]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_cell_to_geogpoint(cell: number): Ptr {
+	const _r = callPtr('s2cell_cell_to_geogpoint_w', ['number'], [cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_cell_to_geog(cell: number): Ptr {
+	const _r = callPtr('s2cell_cell_to_geog_w', ['number'], [cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_to_stbox(cell: number): Ptr {
+	const _r = callPtr('s2cell_to_stbox_w', ['number'], [cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_timestamptz_to_stbox(cell: number, t: TimestampTz): Ptr {
+	const _r = callPtr('s2cell_timestamptz_to_stbox_w', ['number', 'bigint'], [cell, BigInt(t)]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_tstzspan_to_stbox(cell: number, s: Ptr): Ptr {
+	const _r = callPtr('s2cell_tstzspan_to_stbox_w', ['number', ptrArgType()], [cell, ptrArgVal(s)]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_edge_neighbors_set(cell: number): Ptr {
+	const _r = callPtr('s2cell_edge_neighbors_set_w', ['number'], [cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_cell_to_children_set(cell: number, children_level: number): Ptr {
+	const _r = callPtr('s2cell_cell_to_children_set_w', ['number', 'number'], [cell, children_level]);
+	checkMeosError();
+	return _r;
+}
+
+export function ts2cell_in(str: string): Ptr {
+	const _r = callPtr('ts2cell_in_w', ['string'], [str]);
+	checkMeosError();
+	return _r;
+}
+
+export function ts2cell_make(value: number, t: TimestampTz): Ptr {
+	const _r = callPtr('ts2cell_make_w', ['number', 'bigint'], [value, BigInt(t)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ts2cellinst_make(value: number, t: TimestampTz): Ptr {
+	const _r = callPtr('ts2cellinst_make_w', ['number', 'bigint'], [value, BigInt(t)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ts2cellseq_make(values: Ptr, times: Ptr, count: number, lower_inc: boolean, upper_inc: boolean): Ptr {
+	const _r = callPtr('ts2cellseq_make_w', [ptrArgType(), ptrArgType(), 'number', 'number', 'number'], [ptrArgVal(values), ptrArgVal(times), count, lower_inc ? 1 : 0, upper_inc ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function ts2cellseqset_make(sequences: Ptr, count: number): Ptr {
+	const _r = callPtr('ts2cellseqset_make_w', [ptrArgType(), 'number'], [ptrArgVal(sequences), count]);
+	checkMeosError();
+	return _r;
+}
+
+export function ts2cell_start_value(temp: Ptr): number {
+	const _r = call<number>('ts2cell_start_value_w', 'number', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ts2cell_end_value(temp: Ptr): number {
+	const _r = call<number>('ts2cell_end_value_w', 'number', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ts2cell_value_n(temp: Ptr, n: number): number {
+	const _r = call<number>('ts2cell_value_n_w', 'number', [ptrArgType(), 'number'], [ptrArgVal(temp), n]);
+	checkMeosError();
+	return _r;
+}
+
+export function ts2cell_values(temp: Ptr, count: Ptr): Ptr {
+	const _r = callPtr('ts2cell_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ts2cell_value_at_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): number {
+	const _r = call<number>('ts2cell_value_at_timestamptz_w', 'number', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function s2cell_to_set(cell: number): Ptr {
+	const _r = callPtr('s2cell_to_set_w', ['number'], [cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function tbigint_to_ts2cell(temp: Ptr): Ptr {
+	const _r = callPtr('tbigint_to_ts2cell_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ts2cell_to_tbigint(temp: Ptr): Ptr {
+	const _r = callPtr('ts2cell_to_tbigint_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_eq_s2cell_ts2cell(cell: number, temp: Ptr): number {
+	const _r = call<number>('ever_eq_s2cell_ts2cell_w', 'number', ['number', ptrArgType()], [cell, ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_eq_ts2cell_s2cell(temp: Ptr, cell: number): number {
+	const _r = call<number>('ever_eq_ts2cell_s2cell_w', 'number', [ptrArgType(), 'number'], [ptrArgVal(temp), cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_ne_s2cell_ts2cell(cell: number, temp: Ptr): number {
+	const _r = call<number>('ever_ne_s2cell_ts2cell_w', 'number', ['number', ptrArgType()], [cell, ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_ne_ts2cell_s2cell(temp: Ptr, cell: number): number {
+	const _r = call<number>('ever_ne_ts2cell_s2cell_w', 'number', [ptrArgType(), 'number'], [ptrArgVal(temp), cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_eq_s2cell_ts2cell(cell: number, temp: Ptr): number {
+	const _r = call<number>('always_eq_s2cell_ts2cell_w', 'number', ['number', ptrArgType()], [cell, ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_eq_ts2cell_s2cell(temp: Ptr, cell: number): number {
+	const _r = call<number>('always_eq_ts2cell_s2cell_w', 'number', [ptrArgType(), 'number'], [ptrArgVal(temp), cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_ne_s2cell_ts2cell(cell: number, temp: Ptr): number {
+	const _r = call<number>('always_ne_s2cell_ts2cell_w', 'number', ['number', ptrArgType()], [cell, ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_ne_ts2cell_s2cell(temp: Ptr, cell: number): number {
+	const _r = call<number>('always_ne_ts2cell_s2cell_w', 'number', [ptrArgType(), 'number'], [ptrArgVal(temp), cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_eq_ts2cell_ts2cell(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('ever_eq_ts2cell_ts2cell_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ever_ne_ts2cell_ts2cell(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('ever_ne_ts2cell_ts2cell_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_eq_ts2cell_ts2cell(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('always_eq_ts2cell_ts2cell_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function always_ne_ts2cell_ts2cell(temp1: Ptr, temp2: Ptr): number {
+	const _r = call<number>('always_ne_ts2cell_ts2cell_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function teq_s2cell_ts2cell(cell: number, temp: Ptr): Ptr {
+	const _r = callPtr('teq_s2cell_ts2cell_w', ['number', ptrArgType()], [cell, ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function teq_ts2cell_s2cell(temp: Ptr, cell: number): Ptr {
+	const _r = callPtr('teq_ts2cell_s2cell_w', [ptrArgType(), 'number'], [ptrArgVal(temp), cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function teq_ts2cell_ts2cell(temp1: Ptr, temp2: Ptr): Ptr {
+	const _r = callPtr('teq_ts2cell_ts2cell_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tne_s2cell_ts2cell(cell: number, temp: Ptr): Ptr {
+	const _r = callPtr('tne_s2cell_ts2cell_w', ['number', ptrArgType()], [cell, ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+export function tne_ts2cell_s2cell(temp: Ptr, cell: number): Ptr {
+	const _r = callPtr('tne_ts2cell_s2cell_w', [ptrArgType(), 'number'], [ptrArgVal(temp), cell]);
+	checkMeosError();
+	return _r;
+}
+
+export function tne_ts2cell_ts2cell(temp1: Ptr, temp2: Ptr): Ptr {
+	const _r = callPtr('tne_ts2cell_ts2cell_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ts2cell_cell_to_token(temp: Ptr): Ptr {
+	const _r = callPtr('ts2cell_cell_to_token_w', [ptrArgType()], [ptrArgVal(temp)]);
+	checkMeosError();
+	return _r;
+}
+
+
+// === pg_bool.h ===
+
+export function bool_eq(arg1: boolean, arg2: boolean): boolean {
+	const _r = call<number>('bool_eq_w', 'number', ['number', 'number'], [arg1 ? 1 : 0, arg2 ? 1 : 0]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function bool_ge(arg1: boolean, arg2: boolean): boolean {
+	const _r = call<number>('bool_ge_w', 'number', ['number', 'number'], [arg1 ? 1 : 0, arg2 ? 1 : 0]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function bool_gt(arg1: boolean, arg2: boolean): boolean {
+	const _r = call<number>('bool_gt_w', 'number', ['number', 'number'], [arg1 ? 1 : 0, arg2 ? 1 : 0]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function bool_hash(arg: boolean): number {
+	const _r = call<number>('bool_hash_w', 'number', ['number'], [arg ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+export function bool_hash_extended(arg: boolean, seed: number): number {
+	const _r = Number(call<bigint>('bool_hash_extended_w', 'bigint', ['number', 'bigint'], [arg ? 1 : 0, BigInt(seed)]));
+	checkMeosError();
+	return _r;
+}
+
+export function bool_le(arg1: boolean, arg2: boolean): boolean {
+	const _r = call<number>('bool_le_w', 'number', ['number', 'number'], [arg1 ? 1 : 0, arg2 ? 1 : 0]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function bool_lt(arg1: boolean, arg2: boolean): boolean {
+	const _r = call<number>('bool_lt_w', 'number', ['number', 'number'], [arg1 ? 1 : 0, arg2 ? 1 : 0]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function bool_ne(arg1: boolean, arg2: boolean): boolean {
+	const _r = call<number>('bool_ne_w', 'number', ['number', 'number'], [arg1 ? 1 : 0, arg2 ? 1 : 0]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function bool_to_text(b: boolean): string {
+	const _r = call<string>('bool_to_text_w', 'string', ['number'], [b ? 1 : 0]);
+	checkMeosError();
+	return _r;
+}
+
+
+// === pg_date.h ===
+
+export function add_date_int(date: DateADT, days: number): DateADT {
+	const _r = call<DateADT>('add_date_int_w', 'number', ['number', 'number'], [date, days]);
+	checkMeosError();
+	return _r;
+}
+
+export function add_date_interval(date: DateADT, interv: Ptr): DateADT {
+	const _r = call<DateADT>('add_date_interval_w', 'number', ['number', ptrArgType()], [date, ptrArgVal(interv)]);
+	checkMeosError();
+	return _r;
+}
+
+export function cmp_date_timestamp(date: DateADT, ts: number): number {
+	const _r = call<number>('cmp_date_timestamp_w', 'number', ['number', 'bigint'], [date, BigInt(ts)]);
+	checkMeosError();
+	return _r;
+}
+
+export function cmp_date_date(date1: DateADT, date2: DateADT): number {
+	const _r = call<number>('cmp_date_date_w', 'number', ['number', 'number'], [date1, date2]);
+	checkMeosError();
+	return _r;
+}
+
+export function cmp_date_timestamptz(date: DateADT, tstz: TimestampTz): number {
+	const _r = call<number>('cmp_date_timestamptz_w', 'number', ['number', 'bigint'], [date, BigInt(tstz)]);
+	checkMeosError();
+	return _r;
+}
+
+export function cmp_timestamp_date(ts: number, date: DateADT): number {
+	const _r = call<number>('cmp_timestamp_date_w', 'number', ['bigint', 'number'], [BigInt(ts), date]);
+	checkMeosError();
+	return _r;
+}
+
+export function cmp_timestamptz_date(tstz: TimestampTz, date: DateADT): number {
+	const _r = call<number>('cmp_timestamptz_date_w', 'number', ['bigint', 'number'], [BigInt(tstz), date]);
+	checkMeosError();
+	return _r;
+}
+
+export function date_extract(date: DateADT, units: string): number {
+	const _r = call<number>('date_extract_w', 'number', ['number', 'string'], [date, units]);
+	checkMeosError();
+	return _r;
+}
+
+export function date_hash(date: DateADT): number {
+	const _r = call<number>('date_hash_w', 'number', ['number'], [date]);
+	checkMeosError();
+	return _r;
+}
+
+export function date_hash_extended(date: DateADT, seed: number): number {
+	const _r = Number(call<bigint>('date_hash_extended_w', 'bigint', ['number', 'bigint'], [date, BigInt(seed)]));
+	checkMeosError();
+	return _r;
+}
+
+export function date_is_finite(date: DateADT): boolean {
+	const _r = call<number>('date_is_finite_w', 'number', ['number'], [date]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function date_larger(date1: DateADT, date2: DateADT): DateADT {
+	const _r = call<DateADT>('date_larger_w', 'number', ['number', 'number'], [date1, date2]);
+	checkMeosError();
+	return _r;
+}
+
+export function date_make(year: number, mon: number, mday: number): DateADT {
+	const _r = call<DateADT>('date_make_w', 'number', ['number', 'number', 'number'], [year, mon, mday]);
+	checkMeosError();
+	return _r;
+}
+
+export function date_smaller(date1: DateADT, date2: DateADT): DateADT {
+	const _r = call<DateADT>('date_smaller_w', 'number', ['number', 'number'], [date1, date2]);
+	checkMeosError();
+	return _r;
+}
+
+export function date_time_to_timestamp(date: DateADT, time: number): number {
+	const _r = call<number>('date_time_to_timestamp_w', 'number', ['number', 'number'], [date, time]);
+	checkMeosError();
+	return _r;
+}
+
+export function date_to_timestamp(date: DateADT): number {
+	const _r = call<number>('date_to_timestamp_w', 'number', ['number'], [date]);
+	checkMeosError();
+	return _r;
+}
+
+export function date_to_timestamptz(date: DateADT): TimestampTz {
+	const _r = call<TimestampTz>('date_to_timestamptz_w', 'number', ['number'], [date]);
+	checkMeosError();
+	return _r;
+}
+
+export function eq_date_date(date1: DateADT, date2: DateADT): boolean {
+	const _r = call<number>('eq_date_date_w', 'number', ['number', 'number'], [date1, date2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function eq_date_timestamp(date: DateADT, ts: number): boolean {
+	const _r = call<number>('eq_date_timestamp_w', 'number', ['number', 'bigint'], [date, BigInt(ts)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function eq_date_timestamptz(date: DateADT, tstz: TimestampTz): boolean {
+	const _r = call<number>('eq_date_timestamptz_w', 'number', ['number', 'bigint'], [date, BigInt(tstz)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function eq_timestamp_date(ts: number, date: DateADT): boolean {
+	const _r = call<number>('eq_timestamp_date_w', 'number', ['bigint', 'number'], [BigInt(ts), date]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function eq_timestamptz_date(tstz: TimestampTz, date: DateADT): boolean {
+	const _r = call<number>('eq_timestamptz_date_w', 'number', ['bigint', 'number'], [BigInt(tstz), date]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function ge_date_date(date1: DateADT, date2: DateADT): boolean {
+	const _r = call<number>('ge_date_date_w', 'number', ['number', 'number'], [date1, date2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function ge_date_timestamp(date: DateADT, ts: number): boolean {
+	const _r = call<number>('ge_date_timestamp_w', 'number', ['number', 'bigint'], [date, BigInt(ts)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function ge_date_timestamptz(date: DateADT, tstz: TimestampTz): boolean {
+	const _r = call<number>('ge_date_timestamptz_w', 'number', ['number', 'bigint'], [date, BigInt(tstz)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function ge_timestamp_date(ts: number, date: DateADT): boolean {
+	const _r = call<number>('ge_timestamp_date_w', 'number', ['bigint', 'number'], [BigInt(ts), date]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function ge_timestamptz_date(tstz: TimestampTz, date: DateADT): boolean {
+	const _r = call<number>('ge_timestamptz_date_w', 'number', ['bigint', 'number'], [BigInt(tstz), date]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function gt_date_date(date1: DateADT, date2: DateADT): boolean {
+	const _r = call<number>('gt_date_date_w', 'number', ['number', 'number'], [date1, date2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function gt_date_timestamp(date: DateADT, ts: number): boolean {
+	const _r = call<number>('gt_date_timestamp_w', 'number', ['number', 'bigint'], [date, BigInt(ts)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function gt_date_timestamptz(date: DateADT, tstz: TimestampTz): boolean {
+	const _r = call<number>('gt_date_timestamptz_w', 'number', ['number', 'bigint'], [date, BigInt(tstz)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function gt_timestamp_date(ts: number, date: DateADT): boolean {
+	const _r = call<number>('gt_timestamp_date_w', 'number', ['bigint', 'number'], [BigInt(ts), date]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function gt_timestamptz_date(tstz: TimestampTz, date: DateADT): boolean {
+	const _r = call<number>('gt_timestamptz_date_w', 'number', ['bigint', 'number'], [BigInt(tstz), date]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function le_date_date(date1: DateADT, date2: DateADT): boolean {
+	const _r = call<number>('le_date_date_w', 'number', ['number', 'number'], [date1, date2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function le_date_timestamp(date: DateADT, ts: number): boolean {
+	const _r = call<number>('le_date_timestamp_w', 'number', ['number', 'bigint'], [date, BigInt(ts)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function le_date_timestamptz(date: DateADT, tstz: TimestampTz): boolean {
+	const _r = call<number>('le_date_timestamptz_w', 'number', ['number', 'bigint'], [date, BigInt(tstz)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function le_timestamp_date(ts: number, date: DateADT): boolean {
+	const _r = call<number>('le_timestamp_date_w', 'number', ['bigint', 'number'], [BigInt(ts), date]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function le_timestamptz_date(tstz: TimestampTz, date: DateADT): boolean {
+	const _r = call<number>('le_timestamptz_date_w', 'number', ['bigint', 'number'], [BigInt(tstz), date]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function lt_date_date(date1: DateADT, date2: DateADT): boolean {
+	const _r = call<number>('lt_date_date_w', 'number', ['number', 'number'], [date1, date2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function lt_date_timestamp(date: DateADT, ts: number): boolean {
+	const _r = call<number>('lt_date_timestamp_w', 'number', ['number', 'bigint'], [date, BigInt(ts)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function lt_date_timestamptz(date: DateADT, tstz: TimestampTz): boolean {
+	const _r = call<number>('lt_date_timestamptz_w', 'number', ['number', 'bigint'], [date, BigInt(tstz)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function lt_timestamp_date(ts: number, date: DateADT): boolean {
+	const _r = call<number>('lt_timestamp_date_w', 'number', ['bigint', 'number'], [BigInt(ts), date]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function lt_timestamptz_date(tstz: TimestampTz, date: DateADT): boolean {
+	const _r = call<number>('lt_timestamptz_date_w', 'number', ['bigint', 'number'], [BigInt(tstz), date]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function minus_date_date(date1: DateADT, date2: DateADT): number {
+	const _r = call<number>('minus_date_date_w', 'number', ['number', 'number'], [date1, date2]);
+	checkMeosError();
+	return _r;
+}
+
+export function minus_date_int(date: DateADT, days: number): DateADT {
+	const _r = call<DateADT>('minus_date_int_w', 'number', ['number', 'number'], [date, days]);
+	checkMeosError();
+	return _r;
+}
+
+export function minus_date_interval(date: DateADT, span: Ptr): DateADT {
+	const _r = call<DateADT>('minus_date_interval_w', 'number', ['number', ptrArgType()], [date, ptrArgVal(span)]);
+	checkMeosError();
+	return _r;
+}
+
+export function ne_date_date(date1: DateADT, date2: DateADT): boolean {
+	const _r = call<number>('ne_date_date_w', 'number', ['number', 'number'], [date1, date2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function ne_date_timestamp(date: DateADT, ts: number): boolean {
+	const _r = call<number>('ne_date_timestamp_w', 'number', ['number', 'bigint'], [date, BigInt(ts)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function ne_date_timestamptz(date: DateADT, tstz: TimestampTz): boolean {
+	const _r = call<number>('ne_date_timestamptz_w', 'number', ['number', 'bigint'], [date, BigInt(tstz)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function ne_timestamp_date(ts: number, date: DateADT): boolean {
+	const _r = call<number>('ne_timestamp_date_w', 'number', ['bigint', 'number'], [BigInt(ts), date]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function ne_timestamptz_date(tstz: TimestampTz, date: DateADT): boolean {
+	const _r = call<number>('ne_timestamptz_date_w', 'number', ['bigint', 'number'], [BigInt(tstz), date]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function timestamp_to_date(ts: number): DateADT {
+	const _r = call<DateADT>('timestamp_to_date_w', 'number', ['bigint'], [BigInt(ts)]);
+	checkMeosError();
+	return _r;
+}
+
+export function timestamptz_to_date(tstz: TimestampTz): DateADT {
+	const _r = call<DateADT>('timestamptz_to_date_w', 'number', ['bigint'], [BigInt(tstz)]);
+	checkMeosError();
+	return _r;
+}
+
+
+// === pg_float.h ===
+
+export function add_float8_float8(num1: number, num2: number): number {
+	const _r = call<number>('add_float8_float8_w', 'number', ['number', 'number'], [num1, num2]);
+	checkMeosError();
+	return _r;
+}
+
+export function div_float8_float8(num1: number, num2: number): number {
+	const _r = call<number>('div_float8_float8_w', 'number', ['number', 'number'], [num1, num2]);
+	checkMeosError();
+	return _r;
+}
+
+export function eq_float8_float8(num1: number, num2: number): boolean {
+	const _r = call<number>('eq_float8_float8_w', 'number', ['number', 'number'], [num1, num2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function float8_abs(num: number): number {
+	const _r = call<number>('float8_abs_w', 'number', ['number'], [num]);
+	checkMeosError();
+	return _r;
+}
+
+export function float8_ceil(num: number): number {
+	const _r = call<number>('float8_ceil_w', 'number', ['number'], [num]);
+	checkMeosError();
+	return _r;
+}
+
+export function float8_cmp(num1: number, num2: number): number {
+	const _r = call<number>('float8_cmp_w', 'number', ['number', 'number'], [num1, num2]);
+	checkMeosError();
+	return _r;
+}
+
+export function float8_cos(num: number): number {
+	const _r = call<number>('float8_cos_w', 'number', ['number'], [num]);
+	checkMeosError();
+	return _r;
+}
+
+export function float8_degrees(num: number): number {
+	const _r = call<number>('float8_degrees_w', 'number', ['number'], [num]);
+	checkMeosError();
+	return _r;
+}
+
+export function float8_exp(num: number): number {
+	const _r = call<number>('float8_exp_w', 'number', ['number'], [num]);
+	checkMeosError();
+	return _r;
+}
+
+export function float8_floor(num: number): number {
+	const _r = call<number>('float8_floor_w', 'number', ['number'], [num]);
+	checkMeosError();
+	return _r;
+}
+
+export function float8_hash(num: number): number {
+	const _r = call<number>('float8_hash_w', 'number', ['number'], [num]);
+	checkMeosError();
+	return _r;
+}
+
+export function float8_hash_extended(num: number, seed: number): number {
+	const _r = Number(call<bigint>('float8_hash_extended_w', 'bigint', ['number', 'bigint'], [num, BigInt(seed)]));
+	checkMeosError();
+	return _r;
+}
+
+export function float8_in(str: string): number {
+	const _r = call<number>('float8_in_w', 'number', ['string'], [str]);
+	checkMeosError();
+	return _r;
+}
+
+export function float8_ln(num: number): number {
+	const _r = call<number>('float8_ln_w', 'number', ['number'], [num]);
+	checkMeosError();
+	return _r;
+}
+
+export function float8_log10(num: number): number {
+	const _r = call<number>('float8_log10_w', 'number', ['number'], [num]);
+	checkMeosError();
+	return _r;
+}
+
+export function float8_radians(num: number): number {
+	const _r = call<number>('float8_radians_w', 'number', ['number'], [num]);
+	checkMeosError();
+	return _r;
+}
+
+export function float8_sin(num: number): number {
+	const _r = call<number>('float8_sin_w', 'number', ['number'], [num]);
+	checkMeosError();
+	return _r;
+}
+
+export function float8_tan(num: number): number {
+	const _r = call<number>('float8_tan_w', 'number', ['number'], [num]);
+	checkMeosError();
+	return _r;
+}
+
+export function ge_float8_float8(num1: number, num2: number): boolean {
+	const _r = call<number>('ge_float8_float8_w', 'number', ['number', 'number'], [num1, num2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function gt_float8_float8(num1: number, num2: number): boolean {
+	const _r = call<number>('gt_float8_float8_w', 'number', ['number', 'number'], [num1, num2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function le_float8_float8(num1: number, num2: number): boolean {
+	const _r = call<number>('le_float8_float8_w', 'number', ['number', 'number'], [num1, num2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function lt_float8_float8(num1: number, num2: number): boolean {
+	const _r = call<number>('lt_float8_float8_w', 'number', ['number', 'number'], [num1, num2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function minus_float8_float8(num1: number, num2: number): number {
+	const _r = call<number>('minus_float8_float8_w', 'number', ['number', 'number'], [num1, num2]);
+	checkMeosError();
+	return _r;
+}
+
+export function mul_float8_float8(num1: number, num2: number): number {
+	const _r = call<number>('mul_float8_float8_w', 'number', ['number', 'number'], [num1, num2]);
+	checkMeosError();
+	return _r;
+}
+
+export function ne_float8_float8(num1: number, num2: number): boolean {
+	const _r = call<number>('ne_float8_float8_w', 'number', ['number', 'number'], [num1, num2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+
+// === pg_int.h ===
+
+export function add_int32_int32(num1: number, num2: number): number {
+	const _r = call<number>('add_int32_int32_w', 'number', ['number', 'number'], [num1, num2]);
+	checkMeosError();
+	return _r;
+}
+
+export function add_int64_int64(num1: number, num2: number): number {
+	const _r = Number(call<bigint>('add_int64_int64_w', 'bigint', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)]));
+	checkMeosError();
+	return _r;
+}
+
+export function div_int32_int32(num1: number, num2: number): number {
+	const _r = call<number>('div_int32_int32_w', 'number', ['number', 'number'], [num1, num2]);
+	checkMeosError();
+	return _r;
+}
+
+export function div_int64_int64(num1: number, num2: number): number {
+	const _r = Number(call<bigint>('div_int64_int64_w', 'bigint', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)]));
+	checkMeosError();
+	return _r;
+}
+
+export function eq_int32_int32(num1: number, num2: number): boolean {
+	const _r = call<number>('eq_int32_int32_w', 'number', ['number', 'number'], [num1, num2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function eq_int32_int64(num1: number, num2: number): boolean {
+	const _r = call<number>('eq_int32_int64_w', 'number', ['number', 'bigint'], [num1, BigInt(num2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function eq_int64_int32(num1: number, num2: number): boolean {
+	const _r = call<number>('eq_int64_int32_w', 'number', ['bigint', 'number'], [BigInt(num1), num2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function eq_int64_int64(num1: number, num2: number): boolean {
+	const _r = call<number>('eq_int64_int64_w', 'number', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function ge_int32_int32(num1: number, num2: number): boolean {
+	const _r = call<number>('ge_int32_int32_w', 'number', ['number', 'number'], [num1, num2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_end_instant(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_end_instant_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function ge_int32_int64(num1: number, num2: number): boolean {
+	const _r = call<number>('ge_int32_int64_w', 'number', ['number', 'bigint'], [num1, BigInt(num2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_end_sequence(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_end_sequence_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function ge_int64_int32(num1: number, num2: number): boolean {
+	const _r = call<number>('ge_int64_int32_w', 'number', ['bigint', 'number'], [BigInt(num1), num2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_end_value(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_end_value_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function ge_int64_int64(num1: number, num2: number): boolean {
+	const _r = call<number>('ge_int64_int64_w', 'number', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_geom(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_geom_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function gt_int32_int32(num1: number, num2: number): boolean {
+	const _r = call<number>('gt_int32_int32_w', 'number', ['number', 'number'], [num1, num2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_instant_n(temp: Ptr, n: number): Ptr {
-	const _r = callPtr('trgeometry_instant_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), n]);
+export function gt_int32_int64(num1: number, num2: number): boolean {
+	const _r = call<number>('gt_int32_int64_w', 'number', ['number', 'bigint'], [num1, BigInt(num2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_instants(temp: Ptr, count: Ptr): Ptr {
-	const _r = callPtr('trgeometry_instants_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]);
+export function gt_int64_int32(num1: number, num2: number): boolean {
+	const _r = call<number>('gt_int64_int32_w', 'number', ['bigint', 'number'], [BigInt(num1), num2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_points(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_points_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function gt_int64_int64(num1: number, num2: number): boolean {
+	const _r = call<number>('gt_int64_int64_w', 'number', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_yaw(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_yaw_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function int32_abs(num: number): number {
+	const _r = call<number>('int32_abs_w', 'number', ['number'], [num]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_pitch(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_pitch_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function int32_cmp(l: number, r: number): number {
+	const _r = call<number>('int32_cmp_w', 'number', ['number', 'number'], [l, r]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_roll(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_roll_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function int32_hash(val: number): number {
+	const _r = call<number>('int32_hash_w', 'number', ['number'], [val]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_segments(temp: Ptr, count: Ptr): Ptr {
-	const _r = callPtr('trgeometry_segments_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]);
+export function int32_hash_extended(val: number, seed: number): number {
+	const _r = Number(call<bigint>('int32_hash_extended_w', 'bigint', ['number', 'bigint'], [val, BigInt(seed)]));
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_sequence_n(temp: Ptr, i: number): Ptr {
-	const _r = callPtr('trgeometry_sequence_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), i]);
+export function int32_in(str: string): number {
+	const _r = call<number>('int32_in_w', 'number', ['string'], [str]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_sequences(temp: Ptr, count: Ptr): Ptr {
-	const _r = callPtr('trgeometry_sequences_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]);
+export function int32_out(num: number): string {
+	const _r = call<string>('int32_out_w', 'string', ['number'], [num]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_start_instant(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_start_instant_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function int64_abs(num: number): number {
+	const _r = Number(call<bigint>('int64_abs_w', 'bigint', ['bigint'], [BigInt(num)]));
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_start_sequence(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_start_sequence_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function int64_cmp(l: number, r: number): number {
+	const _r = call<number>('int64_cmp_w', 'number', ['bigint', 'bigint'], [BigInt(l), BigInt(r)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_start_value(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_start_value_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function int64_hash(num: number): number {
+	const _r = call<number>('int64_hash_w', 'number', ['bigint'], [BigInt(num)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_value_n(temp: Ptr, n: number): Ptr {
-	const _r = callPtr('trgeometry_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), n]);
+export function int64_hash_extended(num: number, seed: number): number {
+	const _r = Number(call<bigint>('int64_hash_extended_w', 'bigint', ['bigint', 'bigint'], [BigInt(num), BigInt(seed)]));
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_traversed_area(temp: Ptr, unary_union: boolean): Ptr {
-	const _r = callPtr('trgeometry_traversed_area_w', [ptrArgType(), 'number'], [ptrArgVal(temp), unary_union ? 1 : 0]);
+export function int64_in(str: string): number {
+	const _r = Number(call<bigint>('int64_in_w', 'bigint', ['string'], [str]));
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_centroid(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_centroid_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function int64_out(num: number): string {
+	const _r = call<string>('int64_out_w', 'string', ['bigint'], [BigInt(num)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_convex_hull(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_convex_hull_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function le_int32_int32(num1: number, num2: number): boolean {
+	const _r = call<number>('le_int32_int32_w', 'number', ['number', 'number'], [num1, num2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_body_point_trajectory(temp: Ptr, gs: Ptr): Ptr {
-	const _r = callPtr('trgeometry_body_point_trajectory_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function le_int32_int64(num1: number, num2: number): boolean {
+	const _r = call<number>('le_int32_int64_w', 'number', ['number', 'bigint'], [num1, BigInt(num2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_space_boxes(temp: Ptr, xsize: number, ysize: number, zsize: number, sorigin: Ptr, bitmatrix: boolean, border_inc: boolean, count: Ptr): Ptr {
-	const _r = callPtr('trgeometry_space_boxes_w', [ptrArgType(), 'number', 'number', 'number', ptrArgType(), 'number', 'number', ptrArgType()], [ptrArgVal(temp), xsize, ysize, zsize, ptrArgVal(sorigin), bitmatrix ? 1 : 0, border_inc ? 1 : 0, ptrArgVal(count)]);
+export function le_int64_int32(num1: number, num2: number): boolean {
+	const _r = call<number>('le_int64_int32_w', 'number', ['bigint', 'number'], [BigInt(num1), num2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function le_int64_int64(num1: number, num2: number): boolean {
+	const _r = call<number>('le_int64_int64_w', 'number', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function lt_int32_int32(num1: number, num2: number): boolean {
+	const _r = call<number>('lt_int32_int32_w', 'number', ['number', 'number'], [num1, num2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function lt_int32_int64(num1: number, num2: number): boolean {
+	const _r = call<number>('lt_int32_int64_w', 'number', ['number', 'bigint'], [num1, BigInt(num2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function lt_int64_int32(num1: number, num2: number): boolean {
+	const _r = call<number>('lt_int64_int32_w', 'number', ['bigint', 'number'], [BigInt(num1), num2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function lt_int64_int64(num1: number, num2: number): boolean {
+	const _r = call<number>('lt_int64_int64_w', 'number', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function minus_int32_int32(num1: number, num2: number): number {
+	const _r = call<number>('minus_int32_int32_w', 'number', ['number', 'number'], [num1, num2]);
+	checkMeosError();
+	return _r;
+}
+
+export function minus_int64_int64(num1: number, num2: number): number {
+	const _r = Number(call<bigint>('minus_int64_int64_w', 'bigint', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)]));
+	checkMeosError();
+	return _r;
+}
+
+export function mul_int32_int32(num1: number, num2: number): number {
+	const _r = call<number>('mul_int32_int32_w', 'number', ['number', 'number'], [num1, num2]);
+	checkMeosError();
+	return _r;
+}
+
+export function mul_int64_int64(num1: number, num2: number): number {
+	const _r = Number(call<bigint>('mul_int64_int64_w', 'bigint', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)]));
+	checkMeosError();
+	return _r;
+}
+
+export function ne_int32_int32(num1: number, num2: number): boolean {
+	const _r = call<number>('ne_int32_int32_w', 'number', ['number', 'number'], [num1, num2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function ne_int32_int64(num1: number, num2: number): boolean {
+	const _r = call<number>('ne_int32_int64_w', 'number', ['number', 'bigint'], [num1, BigInt(num2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function ne_int64_int32(num1: number, num2: number): boolean {
+	const _r = call<number>('ne_int64_int32_w', 'number', ['bigint', 'number'], [BigInt(num1), num2]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function ne_int64_int64(num1: number, num2: number): boolean {
+	const _r = call<number>('ne_int64_int64_w', 'number', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+
+// === pg_interval.h ===
+
+export function add_interval_interval(interv1: Ptr, interv2: Ptr): Ptr {
+	const _r = callPtr('add_interval_interval_w', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function div_interval_float8(interv: Ptr, factor: number): Ptr {
+	const _r = callPtr('div_interval_float8_w', [ptrArgType(), 'number'], [ptrArgVal(interv), factor]);
+	checkMeosError();
+	return _r;
+}
+
+export function interval_copy(interv: Ptr): Ptr {
+	const _r = callPtr('interval_copy_w', [ptrArgType()], [ptrArgVal(interv)]);
+	checkMeosError();
+	return _r;
+}
+
+export function interval_eq(interv1: Ptr, interv2: Ptr): boolean {
+	const _r = call<number>('interval_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function interval_extract(interv: Ptr, units: string): number {
+	const _r = call<number>('interval_extract_w', 'number', [ptrArgType(), 'string'], [ptrArgVal(interv), units]);
+	checkMeosError();
+	return _r;
+}
+
+export function interval_ge(interv1: Ptr, interv2: Ptr): boolean {
+	const _r = call<number>('interval_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function interval_gt(interv1: Ptr, interv2: Ptr): boolean {
+	const _r = call<number>('interval_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function interval_hash(interv: Ptr): number {
+	const _r = call<number>('interval_hash_w', 'number', [ptrArgType()], [ptrArgVal(interv)]);
+	checkMeosError();
+	return _r;
+}
+
+export function interval_hash_extended(interv: Ptr, seed: number): number {
+	const _r = Number(call<bigint>('interval_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(interv), BigInt(seed)]));
+	checkMeosError();
+	return _r;
+}
+
+export function interval_is_finite(interv: Ptr): boolean {
+	const _r = call<number>('interval_is_finite_w', 'number', [ptrArgType()], [ptrArgVal(interv)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function interval_justify_days(interv: Ptr): Ptr {
+	const _r = callPtr('interval_justify_days_w', [ptrArgType()], [ptrArgVal(interv)]);
+	checkMeosError();
+	return _r;
+}
+
+export function interval_justify_hours(interv: Ptr): Ptr {
+	const _r = callPtr('interval_justify_hours_w', [ptrArgType()], [ptrArgVal(interv)]);
+	checkMeosError();
+	return _r;
+}
+
+export function interval_justify_interval(interv: Ptr): Ptr {
+	const _r = callPtr('interval_justify_interval_w', [ptrArgType()], [ptrArgVal(interv)]);
+	checkMeosError();
+	return _r;
+}
+
+export function interval_larger(interv1: Ptr, interv2: Ptr): Ptr {
+	const _r = callPtr('interval_larger_w', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function interval_le(interv1: Ptr, interv2: Ptr): boolean {
+	const _r = call<number>('interval_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function interval_lt(interv1: Ptr, interv2: Ptr): boolean {
+	const _r = call<number>('interval_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function interval_make(years: number, months: number, weeks: number, days: number, hours: number, mins: number, secs: number): Ptr {
+	const _r = callPtr('interval_make_w', ['number', 'number', 'number', 'number', 'number', 'number', 'number'], [years, months, weeks, days, hours, mins, secs]);
+	checkMeosError();
+	return _r;
+}
+
+export function interval_ne(interv1: Ptr, interv2: Ptr): boolean {
+	const _r = call<number>('interval_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0;
+	checkMeosError();
+	return _r;
+}
+
+export function interval_negate(interv: Ptr): Ptr {
+	const _r = callPtr('interval_negate_w', [ptrArgType()], [ptrArgVal(interv)]);
+	checkMeosError();
+	return _r;
+}
+
+export function interval_part(interv: Ptr, units: string): number {
+	const _r = call<number>('interval_part_w', 'number', [ptrArgType(), 'string'], [ptrArgVal(interv), units]);
+	checkMeosError();
+	return _r;
+}
+
+export function interval_scale(interv: Ptr, typmod: number): Ptr {
+	const _r = callPtr('interval_scale_w', [ptrArgType(), 'number'], [ptrArgVal(interv), typmod]);
+	checkMeosError();
+	return _r;
+}
+
+export function interval_smaller(interv1: Ptr, interv2: Ptr): Ptr {
+	const _r = callPtr('interval_smaller_w', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function interval_trunc(interv: Ptr, units: string): Ptr {
+	const _r = callPtr('interval_trunc_w', [ptrArgType(), 'string'], [ptrArgVal(interv), units]);
+	checkMeosError();
+	return _r;
+}
+
+export function minus_interval_interval(interv1: Ptr, interv2: Ptr): Ptr {
+	const _r = callPtr('minus_interval_interval_w', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]);
+	checkMeosError();
+	return _r;
+}
+
+export function mul_float8_interval(factor: number, interv: Ptr): Ptr {
+	const _r = callPtr('mul_float8_interval_w', ['number', ptrArgType()], [factor, ptrArgVal(interv)]);
+	checkMeosError();
+	return _r;
+}
+
+export function mul_interval_float8(interv: Ptr, factor: number): Ptr {
+	const _r = callPtr('mul_interval_float8_w', [ptrArgType(), 'number'], [ptrArgVal(interv), factor]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_space_time_boxes(temp: Ptr, xsize: number, ysize: number, zsize: number, duration: Ptr, sorigin: Ptr, torigin: TimestampTz, bitmatrix: boolean, border_inc: boolean, count: Ptr): Ptr {
-	const _r = callPtr('trgeometry_space_time_boxes_w', [ptrArgType(), 'number', 'number', 'number', ptrArgType(), ptrArgType(), 'bigint', 'number', 'number', ptrArgType()], [ptrArgVal(temp), xsize, ysize, zsize, ptrArgVal(duration), ptrArgVal(sorigin), BigInt(torigin), bitmatrix ? 1 : 0, border_inc ? 1 : 0, ptrArgVal(count)]);
+
+// === pg_text.h ===
+
+export function text_eq(txt1: string, txt2: string): boolean {
+	const _r = call<number>('text_eq_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_stboxes(temp: Ptr, count: Ptr): Ptr {
-	const _r = callPtr('trgeometry_stboxes_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]);
+export function text_ge(txt1: string, txt2: string): boolean {
+	const _r = call<number>('text_ge_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_split_n_stboxes(temp: Ptr, box_count: number, count: Ptr): Ptr {
-	const _r = callPtr('trgeometry_split_n_stboxes_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(temp), box_count, ptrArgVal(count)]);
+export function text_gt(txt1: string, txt2: string): boolean {
+	const _r = call<number>('text_gt_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_split_each_n_stboxes(temp: Ptr, elem_count: number, count: Ptr): Ptr {
-	const _r = callPtr('trgeometry_split_each_n_stboxes_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(temp), elem_count, ptrArgVal(count)]);
+export function text_hash(txt: string, collid: number): number {
+	const _r = call<number>('text_hash_w', 'number', ['string', 'number'], [txt, collid]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_hausdorff_distance(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('trgeometry_hausdorff_distance_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function text_hash_extended(txt: string, seed: number, collid: number): number {
+	const _r = Number(call<bigint>('text_hash_extended_w', 'bigint', ['string', 'bigint', 'number'], [txt, BigInt(seed), collid]));
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_frechet_distance(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('trgeometry_frechet_distance_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function text_le(txt1: string, txt2: string): boolean {
+	const _r = call<number>('text_le_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_dyntimewarp_distance(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('trgeometry_dyntimewarp_distance_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function text_lt(txt1: string, txt2: string): boolean {
+	const _r = call<number>('text_lt_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_frechet_path(temp1: Ptr, temp2: Ptr, count: Ptr): Ptr {
-	const _r = callPtr('trgeometry_frechet_path_w', [ptrArgType(), ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2), ptrArgVal(count)]);
+export function text_ne(txt1: string, txt2: string): boolean {
+	const _r = call<number>('text_ne_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_dyntimewarp_path(temp1: Ptr, temp2: Ptr, count: Ptr): Ptr {
-	const _r = callPtr('trgeometry_dyntimewarp_path_w', [ptrArgType(), ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2), ptrArgVal(count)]);
+export function text_pattern_ge(txt1: string, txt2: string): boolean {
+	const _r = call<number>('text_pattern_ge_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_length(temp: Ptr): number {
-	const _r = call<number>('trgeometry_length_w', 'number', [ptrArgType()], [ptrArgVal(temp)]);
+export function text_pattern_gt(txt1: string, txt2: string): boolean {
+	const _r = call<number>('text_pattern_gt_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_cumulative_length(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_cumulative_length_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function text_pattern_le(txt1: string, txt2: string): boolean {
+	const _r = call<number>('text_pattern_le_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_angular_speed(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_angular_speed_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function text_pattern_lt(txt1: string, txt2: string): boolean {
+	const _r = call<number>('text_pattern_lt_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_speed(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_speed_w', [ptrArgType()], [ptrArgVal(temp)]);
+
+// === pg_time.h ===
+
+export function date_timetz_to_timestamptz(date: DateADT, timetz: Ptr): TimestampTz {
+	const _r = call<TimestampTz>('date_timetz_to_timestamptz_w', 'number', ['number', ptrArgType()], [date, ptrArgVal(timetz)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_twcentroid(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_twcentroid_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function interval_to_time(interv: Ptr): number {
+	const _r = call<number>('interval_to_time_w', 'number', [ptrArgType()], [ptrArgVal(interv)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_append_tinstant(temp: Ptr, inst: Ptr, interp: number, maxdist: number, maxt: Ptr, expand: boolean): Ptr {
-	const _r = callPtr('trgeometry_append_tinstant_w', [ptrArgType(), ptrArgType(), 'number', 'number', ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(inst), interp, maxdist, ptrArgVal(maxt), expand ? 1 : 0]);
+export function minus_time_interval(time: number, interv: Ptr): number {
+	const _r = call<number>('minus_time_interval_w', 'number', ['number', ptrArgType()], [time, ptrArgVal(interv)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_append_tsequence(temp: Ptr, seq: Ptr, expand: boolean): Ptr {
-	const _r = callPtr('trgeometry_append_tsequence_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(seq), expand ? 1 : 0]);
+export function minus_time_time(time1: number, time2: number): Ptr {
+	const _r = callPtr('minus_time_time_w', ['number', 'number'], [time1, time2]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_delete_timestamptz(temp: Ptr, t: TimestampTz, connect: boolean): Ptr {
-	const _r = callPtr('trgeometry_delete_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), connect ? 1 : 0]);
+export function minus_timetz_interval(timetz: Ptr, interv: Ptr): Ptr {
+	const _r = callPtr('minus_timetz_interval_w', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz), ptrArgVal(interv)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_delete_tstzset(temp: Ptr, s: Ptr, connect: boolean): Ptr {
-	const _r = callPtr('trgeometry_delete_tstzset_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(s), connect ? 1 : 0]);
+export function plus_time_interval(time: number, interv: Ptr): number {
+	const _r = call<number>('plus_time_interval_w', 'number', ['number', ptrArgType()], [time, ptrArgVal(interv)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_delete_tstzspan(temp: Ptr, s: Ptr, connect: boolean): Ptr {
-	const _r = callPtr('trgeometry_delete_tstzspan_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(s), connect ? 1 : 0]);
+export function plus_timetz_interval(timetz: Ptr, interv: Ptr): Ptr {
+	const _r = callPtr('plus_timetz_interval_w', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz), ptrArgVal(interv)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_delete_tstzspanset(temp: Ptr, ss: Ptr, connect: boolean): Ptr {
-	const _r = callPtr('trgeometry_delete_tstzspanset_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(ss), connect ? 1 : 0]);
+export function time_cmp(time1: number, time2: number): number {
+	const _r = call<number>('time_cmp_w', 'number', ['number', 'number'], [time1, time2]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_merge(temp1: Ptr, temp2: Ptr): Ptr {
-	const _r = callPtr('trgeometry_merge_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function time_eq(time1: number, time2: number): boolean {
+	const _r = call<number>('time_eq_w', 'number', ['number', 'number'], [time1, time2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_merge_array(temparr: Ptr, count: number): Ptr {
-	const _r = callPtr('trgeometry_merge_array_w', [ptrArgType(), 'number'], [ptrArgVal(temparr), count]);
+export function time_extract(time: number, units: string): number {
+	const _r = call<number>('time_extract_w', 'number', ['number', 'string'], [time, units]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_round(temp: Ptr, maxdd: number): Ptr {
-	const _r = callPtr('trgeometry_round_w', [ptrArgType(), 'number'], [ptrArgVal(temp), maxdd]);
+export function time_ge(time1: number, time2: number): boolean {
+	const _r = call<number>('time_ge_w', 'number', ['number', 'number'], [time1, time2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_set_interp(temp: Ptr, interp: number): Ptr {
-	const _r = callPtr('trgeometry_set_interp_w', [ptrArgType(), 'number'], [ptrArgVal(temp), interp]);
+export function time_gt(time1: number, time2: number): boolean {
+	const _r = call<number>('time_gt_w', 'number', ['number', 'number'], [time1, time2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_as_tinstant(temp: Ptr): Ptr {
-	const _r = callPtr('trgeometry_as_tinstant_w', [ptrArgType()], [ptrArgVal(temp)]);
+export function time_hash(time: number): number {
+	const _r = call<number>('time_hash_w', 'number', ['number'], [time]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_as_tsequence(temp: Ptr, interp_str: string): Ptr {
-	const _r = callPtr('trgeometry_as_tsequence_w', [ptrArgType(), 'string'], [ptrArgVal(temp), interp_str]);
+export function time_hash_extended(time: number, seed: number): number {
+	const _r = Number(call<bigint>('time_hash_extended_w', 'bigint', ['number', 'number'], [time, seed]));
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_as_tsequenceset(temp: Ptr, interp_str: string): Ptr {
-	const _r = callPtr('trgeometry_as_tsequenceset_w', [ptrArgType(), 'string'], [ptrArgVal(temp), interp_str]);
+export function time_larger(time1: number, time2: number): number {
+	const _r = call<number>('time_larger_w', 'number', ['number', 'number'], [time1, time2]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_after_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): Ptr {
-	const _r = callPtr('trgeometry_after_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0]);
+export function time_le(time1: number, time2: number): boolean {
+	const _r = call<number>('time_le_w', 'number', ['number', 'number'], [time1, time2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_before_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): Ptr {
-	const _r = callPtr('trgeometry_before_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0]);
+export function time_lt(time1: number, time2: number): boolean {
+	const _r = call<number>('time_lt_w', 'number', ['number', 'number'], [time1, time2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_restrict_values(temp: Ptr, s: Ptr, atfunc: boolean): Ptr {
-	const _r = callPtr('trgeometry_restrict_values_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(s), atfunc ? 1 : 0]);
+export function time_make(tm_hour: number, tm_min: number, sec: number): number {
+	const _r = call<number>('time_make_w', 'number', ['number', 'number', 'number'], [tm_hour, tm_min, sec]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_restrict_timestamptz(temp: Ptr, t: TimestampTz, atfunc: boolean): Ptr {
-	const _r = callPtr('trgeometry_restrict_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), atfunc ? 1 : 0]);
+export function time_ne(time1: number, time2: number): boolean {
+	const _r = call<number>('time_ne_w', 'number', ['number', 'number'], [time1, time2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_restrict_tstzset(temp: Ptr, s: Ptr, atfunc: boolean): Ptr {
-	const _r = callPtr('trgeometry_restrict_tstzset_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(s), atfunc ? 1 : 0]);
+export function time_overlaps(ts1: number, te1: number, ts2: number, te2: number): boolean {
+	const _r = call<number>('time_overlaps_w', 'number', ['number', 'number', 'number', 'number'], [ts1, te1, ts2, te2]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_restrict_tstzspan(temp: Ptr, s: Ptr, atfunc: boolean): Ptr {
-	const _r = callPtr('trgeometry_restrict_tstzspan_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(s), atfunc ? 1 : 0]);
+export function time_part(time: number, units: string): number {
+	const _r = call<number>('time_part_w', 'number', ['number', 'string'], [time, units]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_restrict_tstzspanset(temp: Ptr, ss: Ptr, atfunc: boolean): Ptr {
-	const _r = callPtr('trgeometry_restrict_tstzspanset_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(ss), atfunc ? 1 : 0]);
+export function time_scale(date: number, typmod: number): number {
+	const _r = call<number>('time_scale_w', 'number', ['number', 'number'], [date, typmod]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_at_geom(temp: Ptr, gs: Ptr): Ptr {
-	const _r = callPtr('trgeometry_at_geom_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function time_smaller(time1: number, time2: number): number {
+	const _r = call<number>('time_smaller_w', 'number', ['number', 'number'], [time1, time2]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_minus_geom(temp: Ptr, gs: Ptr): Ptr {
-	const _r = callPtr('trgeometry_minus_geom_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function time_to_interval(time: number): Ptr {
+	const _r = callPtr('time_to_interval_w', ['number'], [time]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_at_stbox(temp: Ptr, box: Ptr, border_inc: boolean): Ptr {
-	const _r = callPtr('trgeometry_at_stbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(box), border_inc ? 1 : 0]);
+export function time_to_timetz(time: number): Ptr {
+	const _r = callPtr('time_to_timetz_w', ['number'], [time]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_minus_stbox(temp: Ptr, box: Ptr, border_inc: boolean): Ptr {
-	const _r = callPtr('trgeometry_minus_stbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(box), border_inc ? 1 : 0]);
+export function timestamp_to_time(ts: number): number {
+	const _r = call<number>('timestamp_to_time_w', 'number', ['bigint'], [BigInt(ts)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_at_value(temp: Ptr, pose: Ptr): Ptr {
-	const _r = callPtr('trgeometry_at_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+export function timestamptz_to_time(tztz: TimestampTz): number {
+	const _r = call<number>('timestamptz_to_time_w', 'number', ['bigint'], [BigInt(tztz)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_minus_value(temp: Ptr, pose: Ptr): Ptr {
-	const _r = callPtr('trgeometry_minus_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]);
+export function timestamptz_to_timetz(tztz: TimestampTz): Ptr {
+	const _r = callPtr('timestamptz_to_timetz_w', ['bigint'], [BigInt(tztz)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_at_values(temp: Ptr, s: Ptr): Ptr {
-	const _r = callPtr('trgeometry_at_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+export function timetz_at_local(timetz: Ptr): Ptr {
+	const _r = callPtr('timetz_at_local_w', [ptrArgType()], [ptrArgVal(timetz)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_minus_values(temp: Ptr, s: Ptr): Ptr {
-	const _r = callPtr('trgeometry_minus_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+export function timetz_cmp(timetz1: Ptr, timetz2: Ptr): number {
+	const _r = call<number>('timetz_cmp_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_at_timestamptz(temp: Ptr, t: TimestampTz): Ptr {
-	const _r = callPtr('trgeometry_at_timestamptz_w', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(t)]);
+export function timetz_eq(timetz1: Ptr, timetz2: Ptr): boolean {
+	const _r = call<number>('timetz_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_minus_timestamptz(temp: Ptr, t: TimestampTz): Ptr {
-	const _r = callPtr('trgeometry_minus_timestamptz_w', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(t)]);
+export function timetz_extract(timetz: Ptr, units: string): number {
+	const _r = call<number>('timetz_extract_w', 'number', [ptrArgType(), 'string'], [ptrArgVal(timetz), units]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_at_tstzset(temp: Ptr, s: Ptr): Ptr {
-	const _r = callPtr('trgeometry_at_tstzset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+export function timetz_ge(timetz1: Ptr, timetz2: Ptr): boolean {
+	const _r = call<number>('timetz_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_minus_tstzset(temp: Ptr, s: Ptr): Ptr {
-	const _r = callPtr('trgeometry_minus_tstzset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+export function timetz_gt(timetz1: Ptr, timetz2: Ptr): boolean {
+	const _r = call<number>('timetz_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_at_tstzspan(temp: Ptr, s: Ptr): Ptr {
-	const _r = callPtr('trgeometry_at_tstzspan_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+export function timetz_hash(timetz: Ptr): number {
+	const _r = call<number>('timetz_hash_w', 'number', [ptrArgType()], [ptrArgVal(timetz)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_minus_tstzspan(temp: Ptr, s: Ptr): Ptr {
-	const _r = callPtr('trgeometry_minus_tstzspan_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+export function timetz_hash_extended(timetz: Ptr, seed: number): number {
+	const _r = Number(call<bigint>('timetz_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(timetz), BigInt(seed)]));
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_at_tstzspanset(temp: Ptr, ss: Ptr): Ptr {
-	const _r = callPtr('trgeometry_at_tstzspanset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(ss)]);
+export function timetz_in(str: string, typmod: number): Ptr {
+	const _r = callPtr('timetz_in_w', ['string', 'number'], [str, typmod]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_minus_tstzspanset(temp: Ptr, ss: Ptr): Ptr {
-	const _r = callPtr('trgeometry_minus_tstzspanset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(ss)]);
+export function timetz_izone(timetz: Ptr, zone: Ptr): Ptr {
+	const _r = callPtr('timetz_izone_w', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz), ptrArgVal(zone)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_at_elevation(temp: Ptr, s: Ptr): Ptr {
-	const _r = callPtr('trgeometry_at_elevation_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+export function timetz_larger(timetz1: Ptr, timetz2: Ptr): Ptr {
+	const _r = callPtr('timetz_larger_w', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function trgeometry_minus_elevation(temp: Ptr, s: Ptr): Ptr {
-	const _r = callPtr('trgeometry_minus_elevation_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]);
+export function timetz_le(timetz1: Ptr, timetz2: Ptr): boolean {
+	const _r = call<number>('timetz_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tdistance_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr {
-	const _r = callPtr('tdistance_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function timetz_lt(timetz1: Ptr, timetz2: Ptr): boolean {
+	const _r = call<number>('timetz_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tdistance_trgeometry_tpoint(temp1: Ptr, temp2: Ptr): Ptr {
-	const _r = callPtr('tdistance_trgeometry_tpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function timetz_ne(timetz1: Ptr, timetz2: Ptr): boolean {
+	const _r = call<number>('timetz_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tdistance_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): Ptr {
-	const _r = callPtr('tdistance_trgeometry_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function timetz_copy(timetz: Ptr): Ptr {
+	const _r = callPtr('timetz_copy_w', [ptrArgType()], [ptrArgVal(timetz)]);
 	checkMeosError();
 	return _r;
 }
 
-export function nad_stbox_trgeometry(box: Ptr, temp: Ptr): number {
-	const _r = call<number>('nad_stbox_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box), ptrArgVal(temp)]);
+export function timetz_out(timetz: Ptr): string {
+	const _r = call<string>('timetz_out_w', 'string', [ptrArgType()], [ptrArgVal(timetz)]);
 	checkMeosError();
 	return _r;
 }
 
-export function nad_trgeometry_geo(temp: Ptr, gs: Ptr): number {
-	const _r = call<number>('nad_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function timetz_overlaps(ts1: Ptr, te1: Ptr, ts2: Ptr, te2: Ptr): boolean {
+	const _r = call<number>('timetz_overlaps_w', 'number', [ptrArgType(), ptrArgType(), ptrArgType(), ptrArgType()], [ptrArgVal(ts1), ptrArgVal(te1), ptrArgVal(ts2), ptrArgVal(te2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function nad_trgeometry_stbox(temp: Ptr, box: Ptr): number {
-	const _r = call<number>('nad_trgeometry_stbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]);
+export function timetz_part(timetz: Ptr, units: string): number {
+	const _r = call<number>('timetz_part_w', 'number', [ptrArgType(), 'string'], [ptrArgVal(timetz), units]);
 	checkMeosError();
 	return _r;
 }
 
-export function nad_trgeometry_tpoint(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('nad_trgeometry_tpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function timetz_scale(timetz: Ptr, typmod: number): Ptr {
+	const _r = callPtr('timetz_scale_w', [ptrArgType(), 'number'], [ptrArgVal(timetz), typmod]);
 	checkMeosError();
 	return _r;
 }
 
-export function nad_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('nad_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function timetz_smaller(timetz1: Ptr, timetz2: Ptr): Ptr {
+	const _r = callPtr('timetz_smaller_w', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function nai_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr {
-	const _r = callPtr('nai_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function timetz_to_time(timetz: Ptr): number {
+	const _r = call<number>('timetz_to_time_w', 'number', [ptrArgType()], [ptrArgVal(timetz)]);
 	checkMeosError();
 	return _r;
 }
 
-export function nai_trgeometry_tpoint(temp1: Ptr, temp2: Ptr): Ptr {
-	const _r = callPtr('nai_trgeometry_tpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function timetz_zone(timetz: Ptr, zone: string): Ptr {
+	const _r = callPtr('timetz_zone_w', [ptrArgType(), 'string'], [ptrArgVal(timetz), zone]);
 	checkMeosError();
 	return _r;
 }
 
-export function nai_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): Ptr {
-	const _r = callPtr('nai_trgeometry_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+
+// === pg_timestamp.h ===
+
+export function add_timestamp_interval(ts: number, interv: Ptr): number {
+	const _r = call<number>('add_timestamp_interval_w', 'number', ['bigint', ptrArgType()], [BigInt(ts), ptrArgVal(interv)]);
 	checkMeosError();
 	return _r;
 }
 
-export function shortestline_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr {
-	const _r = callPtr('shortestline_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function add_timestamptz_interval(tstz: TimestampTz, interv: Ptr): number {
+	const _r = call<number>('add_timestamptz_interval_w', 'number', ['bigint', ptrArgType()], [BigInt(tstz), ptrArgVal(interv)]);
 	checkMeosError();
 	return _r;
 }
 
-export function shortestline_trgeometry_tpoint(temp1: Ptr, temp2: Ptr): Ptr {
-	const _r = callPtr('shortestline_trgeometry_tpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function add_timestamptz_interval_at_zone(tstz: TimestampTz, interv: Ptr, zone: string): number {
+	const _r = call<number>('add_timestamptz_interval_at_zone_w', 'number', ['bigint', ptrArgType(), 'string'], [BigInt(tstz), ptrArgVal(interv), zone]);
 	checkMeosError();
 	return _r;
 }
 
-export function shortestline_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): Ptr {
-	const _r = callPtr('shortestline_trgeometry_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function cmp_timestamp_timestamp(ts1: number, ts2: number): number {
+	const _r = call<number>('cmp_timestamp_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function always_eq_geo_trgeometry(gs: Ptr, temp: Ptr): number {
-	const _r = call<number>('always_eq_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+export function cmp_timestamp_timestamptz(ts: number, tstz: TimestampTz): number {
+	const _r = call<number>('cmp_timestamp_timestamptz_w', 'number', ['bigint', 'bigint'], [BigInt(ts), BigInt(tstz)]);
 	checkMeosError();
 	return _r;
 }
 
-export function always_eq_trgeometry_geo(temp: Ptr, gs: Ptr): number {
-	const _r = call<number>('always_eq_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function cmp_timestamptz_timestamp(tstz: TimestampTz, ts: number): number {
+	const _r = call<number>('cmp_timestamptz_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(tstz), BigInt(ts)]);
 	checkMeosError();
 	return _r;
 }
 
-export function always_eq_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('always_eq_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function eq_timestamp_timestamp(ts1: number, ts2: number): boolean {
+	const _r = call<number>('eq_timestamp_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function always_ne_geo_trgeometry(gs: Ptr, temp: Ptr): number {
-	const _r = call<number>('always_ne_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+export function eq_timestamp_timestamptz(ts: number, tstz: TimestampTz): boolean {
+	const _r = call<number>('eq_timestamp_timestamptz_w', 'number', ['bigint', 'bigint'], [BigInt(ts), BigInt(tstz)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function always_ne_trgeometry_geo(temp: Ptr, gs: Ptr): number {
-	const _r = call<number>('always_ne_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function eq_timestamptz_timestamp(tstz: TimestampTz, ts: number): boolean {
+	const _r = call<number>('eq_timestamptz_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(tstz), BigInt(ts)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function always_ne_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('always_ne_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function eq_timestamptz_timestamptz(tstz1: TimestampTz, tstz2: TimestampTz): boolean {
+	const _r = call<number>('eq_timestamptz_timestamptz_w', 'number', ['bigint', 'bigint'], [BigInt(tstz1), BigInt(tstz2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function ever_eq_geo_trgeometry(gs: Ptr, temp: Ptr): number {
-	const _r = call<number>('ever_eq_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+export function float8_to_timestamptz(seconds: number): TimestampTz {
+	const _r = call<TimestampTz>('float8_to_timestamptz_w', 'number', ['number'], [seconds]);
 	checkMeosError();
 	return _r;
 }
 
-export function ever_eq_trgeometry_geo(temp: Ptr, gs: Ptr): number {
-	const _r = call<number>('ever_eq_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function gt_timestamp_timestamp(ts1: number, ts2: number): boolean {
+	const _r = call<number>('gt_timestamp_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function ever_eq_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('ever_eq_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function gt_timestamp_timestamptz(ts: number, tstz: TimestampTz): boolean {
+	const _r = call<number>('gt_timestamp_timestamptz_w', 'number', ['bigint', 'bigint'], [BigInt(ts), BigInt(tstz)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function ever_ne_geo_trgeometry(gs: Ptr, temp: Ptr): number {
-	const _r = call<number>('ever_ne_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+export function gt_timestamptz_timestamp(tstz: TimestampTz, ts: number): boolean {
+	const _r = call<number>('gt_timestamptz_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(tstz), BigInt(ts)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function ever_ne_trgeometry_geo(temp: Ptr, gs: Ptr): number {
-	const _r = call<number>('ever_ne_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function ge_timestamp_timestamp(ts1: number, ts2: number): boolean {
+	const _r = call<number>('ge_timestamp_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function ever_ne_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('ever_ne_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function ge_timestamp_timestamptz(ts: number, tstz: TimestampTz): boolean {
+	const _r = call<number>('ge_timestamp_timestamptz_w', 'number', ['bigint', 'bigint'], [BigInt(ts), BigInt(tstz)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function teq_geo_trgeometry(gs: Ptr, temp: Ptr): Ptr {
-	const _r = callPtr('teq_geo_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+export function ge_timestamptz_timestamp(tstz: TimestampTz, ts: number): boolean {
+	const _r = call<number>('ge_timestamptz_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(tstz), BigInt(ts)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function teq_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr {
-	const _r = callPtr('teq_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function le_timestamp_timestamp(ts1: number, ts2: number): boolean {
+	const _r = call<number>('le_timestamp_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tne_geo_trgeometry(gs: Ptr, temp: Ptr): Ptr {
-	const _r = callPtr('tne_geo_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+export function le_timestamp_timestamptz(ts: number, tstz: TimestampTz): boolean {
+	const _r = call<number>('le_timestamp_timestamptz_w', 'number', ['bigint', 'bigint'], [BigInt(ts), BigInt(tstz)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function tne_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr {
-	const _r = callPtr('tne_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function le_timestamptz_timestamp(tstz: TimestampTz, ts: number): boolean {
+	const _r = call<number>('le_timestamptz_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(tstz), BigInt(ts)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function econtains_geo_trgeometry(gs: Ptr, temp: Ptr): number {
-	const _r = call<number>('econtains_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+export function lt_timestamp_timestamp(ts1: number, ts2: number): boolean {
+	const _r = call<number>('lt_timestamp_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function acontains_geo_trgeometry(gs: Ptr, temp: Ptr): number {
-	const _r = call<number>('acontains_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+export function lt_timestamp_timestamptz(ts: number, tstz: TimestampTz): boolean {
+	const _r = call<number>('lt_timestamp_timestamptz_w', 'number', ['bigint', 'bigint'], [BigInt(ts), BigInt(tstz)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function ecovers_geo_trgeometry(gs: Ptr, temp: Ptr): number {
-	const _r = call<number>('ecovers_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+export function lt_timestamptz_timestamp(tstz: TimestampTz, ts: number): boolean {
+	const _r = call<number>('lt_timestamptz_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(tstz), BigInt(ts)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function acovers_geo_trgeometry(gs: Ptr, temp: Ptr): number {
-	const _r = call<number>('acovers_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]);
+export function minus_timestamp_interval(ts: number, interv: Ptr): number {
+	const _r = call<number>('minus_timestamp_interval_w', 'number', ['bigint', ptrArgType()], [BigInt(ts), ptrArgVal(interv)]);
 	checkMeosError();
 	return _r;
 }
 
-export function ecovers_trgeometry_geo(temp: Ptr, gs: Ptr): number {
-	const _r = call<number>('ecovers_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function minus_timestamp_timestamp(ts1: number, ts2: number): Ptr {
+	const _r = callPtr('minus_timestamp_timestamp_w', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function acovers_trgeometry_geo(temp: Ptr, gs: Ptr): number {
-	const _r = call<number>('acovers_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function minus_timestamptz_interval(tstz: TimestampTz, interv: Ptr): TimestampTz {
+	const _r = call<TimestampTz>('minus_timestamptz_interval_w', 'number', ['bigint', ptrArgType()], [BigInt(tstz), ptrArgVal(interv)]);
 	checkMeosError();
 	return _r;
 }
 
-export function edisjoint_trgeometry_geo(temp: Ptr, gs: Ptr): number {
-	const _r = call<number>('edisjoint_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function minus_timestamptz_interval_at_zone(tstz: TimestampTz, interv: Ptr, zone: string): TimestampTz {
+	const _r = call<TimestampTz>('minus_timestamptz_interval_at_zone_w', 'number', ['bigint', ptrArgType(), 'string'], [BigInt(tstz), ptrArgVal(interv), zone]);
 	checkMeosError();
 	return _r;
 }
 
-export function adisjoint_trgeometry_geo(temp: Ptr, gs: Ptr): number {
-	const _r = call<number>('adisjoint_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function minus_timestamptz_timestamptz(tstz1: TimestampTz, tstz2: TimestampTz): Ptr {
+	const _r = callPtr('minus_timestamptz_timestamptz_w', ['bigint', 'bigint'], [BigInt(tstz1), BigInt(tstz2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function eintersects_trgeometry_geo(temp: Ptr, gs: Ptr): number {
-	const _r = call<number>('eintersects_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function ne_timestamp_timestamp(ts1: number, ts2: number): boolean {
+	const _r = call<number>('ne_timestamp_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function aintersects_trgeometry_geo(temp: Ptr, gs: Ptr): number {
-	const _r = call<number>('aintersects_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function ne_timestamp_timestamptz(ts: number, tstz: TimestampTz): boolean {
+	const _r = call<number>('ne_timestamp_timestamptz_w', 'number', ['bigint', 'bigint'], [BigInt(ts), BigInt(tstz)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function etouches_trgeometry_geo(temp: Ptr, gs: Ptr): number {
-	const _r = call<number>('etouches_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function ne_timestamptz_timestamp(tstz: TimestampTz, ts: number): boolean {
+	const _r = call<number>('ne_timestamptz_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(tstz), BigInt(ts)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function atouches_trgeometry_geo(temp: Ptr, gs: Ptr): number {
-	const _r = call<number>('atouches_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]);
+export function timestamp_age(ts1: number, ts2: number): Ptr {
+	const _r = callPtr('timestamp_age_w', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function edwithin_trgeometry_geo(temp: Ptr, gs: Ptr, dist: number): number {
-	const _r = call<number>('edwithin_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(gs), dist]);
+export function timestamp_at_local(ts: number): TimestampTz {
+	const _r = call<TimestampTz>('timestamp_at_local_w', 'number', ['bigint'], [BigInt(ts)]);
 	checkMeosError();
 	return _r;
 }
 
-export function adwithin_trgeometry_geo(temp: Ptr, gs: Ptr, dist: number): number {
-	const _r = call<number>('adwithin_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(gs), dist]);
+export function timestamp_bin(ts: number, stride: Ptr, origin: number): number {
+	const _r = call<number>('timestamp_bin_w', 'number', ['bigint', ptrArgType(), 'bigint'], [BigInt(ts), ptrArgVal(stride), BigInt(origin)]);
 	checkMeosError();
 	return _r;
 }
 
-export function edisjoint_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('edisjoint_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function timestamp_extract(ts: number, units: string): number {
+	const _r = call<number>('timestamp_extract_w', 'number', ['bigint', 'string'], [BigInt(ts), units]);
 	checkMeosError();
 	return _r;
 }
 
-export function adisjoint_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('adisjoint_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function timestamp_hash(ts: number): number {
+	const _r = call<number>('timestamp_hash_w', 'number', ['bigint'], [BigInt(ts)]);
 	checkMeosError();
 	return _r;
 }
 
-export function eintersects_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('eintersects_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function timestamp_hash_extended(tstz: TimestampTz, seed: number): number {
+	const _r = Number(call<bigint>('timestamp_hash_extended_w', 'bigint', ['bigint', 'bigint'], [BigInt(tstz), BigInt(seed)]));
 	checkMeosError();
 	return _r;
 }
 
-export function aintersects_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number {
-	const _r = call<number>('aintersects_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]);
+export function timestamp_is_finite(ts: number): boolean {
+	const _r = call<number>('timestamp_is_finite_w', 'number', ['bigint'], [BigInt(ts)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function edwithin_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr, dist: number): number {
-	const _r = call<number>('edwithin_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp1), ptrArgVal(temp2), dist]);
+export function timestamp_izone(ts: number, zone: Ptr): TimestampTz {
+	const _r = call<TimestampTz>('timestamp_izone_w', 'number', ['bigint', ptrArgType()], [BigInt(ts), ptrArgVal(zone)]);
 	checkMeosError();
 	return _r;
 }
 
-export function adwithin_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr, dist: number): number {
-	const _r = call<number>('adwithin_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp1), ptrArgVal(temp2), dist]);
+export function time_of_day(): string {
+	const _r = call<string>('time_of_day_w', 'string', [], []);
 	checkMeosError();
 	return _r;
 }
 
-
-// === pg_interval.h ===
-
-export function add_interval_interval(interv1: Ptr, interv2: Ptr): Ptr {
-	const _r = callPtr('add_interval_interval_w', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]);
+export function timestamp_larger(ts1: number, ts2: number): number {
+	const _r = call<number>('timestamp_larger_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function div_interval_float8(interv: Ptr, factor: number): Ptr {
-	const _r = callPtr('div_interval_float8_w', [ptrArgType(), 'number'], [ptrArgVal(interv), factor]);
+export function timestamp_make(year: number, month: number, mday: number, hour: number, min: number, sec: number): number {
+	const _r = call<number>('timestamp_make_w', 'number', ['number', 'number', 'number', 'number', 'number', 'number'], [year, month, mday, hour, min, sec]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_copy(interv: Ptr): Ptr {
-	const _r = callPtr('interval_copy_w', [ptrArgType()], [ptrArgVal(interv)]);
+export function timestamp_overlaps(ts1: number, te1: number, ts2: number, te2: number): boolean {
+	const _r = call<number>('timestamp_overlaps_w', 'number', ['bigint', 'bigint', 'bigint', 'bigint'], [BigInt(ts1), BigInt(te1), BigInt(ts2), BigInt(te2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function interval_eq(interv1: Ptr, interv2: Ptr): boolean {
-	const _r = call<number>('interval_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0;
+export function timestamp_part(ts: number, units: string): number {
+	const _r = call<number>('timestamp_part_w', 'number', ['bigint', 'string'], [BigInt(ts), units]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_extract(interv: Ptr, units: string): number {
-	const _r = call<number>('interval_extract_w', 'number', [ptrArgType(), 'string'], [ptrArgVal(interv), units]);
+export function timestamp_scale(ts: number, typmod: number): number {
+	const _r = call<number>('timestamp_scale_w', 'number', ['bigint', 'number'], [BigInt(ts), typmod]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_ge(interv1: Ptr, interv2: Ptr): boolean {
-	const _r = call<number>('interval_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0;
+export function timestamp_smaller(ts1: number, ts2: number): number {
+	const _r = call<number>('timestamp_smaller_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_gt(interv1: Ptr, interv2: Ptr): boolean {
-	const _r = call<number>('interval_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0;
+export function timestamp_to_timestamptz(ts: number): TimestampTz {
+	const _r = call<TimestampTz>('timestamp_to_timestamptz_w', 'number', ['bigint'], [BigInt(ts)]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_hash(interv: Ptr): number {
-	const _r = call<number>('interval_hash_w', 'number', [ptrArgType()], [ptrArgVal(interv)]);
+export function timestamp_trunc(ts: number, units: string): number {
+	const _r = call<number>('timestamp_trunc_w', 'number', ['bigint', 'string'], [BigInt(ts), units]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_hash_extended(interv: Ptr, seed: number): number {
-	const _r = Number(call<bigint>('interval_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(interv), BigInt(seed)]));
+export function timestamp_zone(ts: number, zone: string): TimestampTz {
+	const _r = call<TimestampTz>('timestamp_zone_w', 'number', ['bigint', 'string'], [BigInt(ts), zone]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_is_finite(interv: Ptr): boolean {
-	const _r = call<number>('interval_is_finite_w', 'number', [ptrArgType()], [ptrArgVal(interv)]) !== 0;
+export function timestamptz_age(tstz1: TimestampTz, tstz2: TimestampTz): Ptr {
+	const _r = callPtr('timestamptz_age_w', ['bigint', 'bigint'], [BigInt(tstz1), BigInt(tstz2)]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_justify_days(interv: Ptr): Ptr {
-	const _r = callPtr('interval_justify_days_w', [ptrArgType()], [ptrArgVal(interv)]);
+export function timestamptz_at_local(tstz: TimestampTz): TimestampTz {
+	const _r = call<TimestampTz>('timestamptz_at_local_w', 'number', ['bigint'], [BigInt(tstz)]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_justify_hours(interv: Ptr): Ptr {
-	const _r = callPtr('interval_justify_hours_w', [ptrArgType()], [ptrArgVal(interv)]);
+export function timestamptz_bin(tstz: TimestampTz, stride: Ptr, origin: TimestampTz): TimestampTz {
+	const _r = call<TimestampTz>('timestamptz_bin_w', 'number', ['bigint', ptrArgType(), 'bigint'], [BigInt(tstz), ptrArgVal(stride), BigInt(origin)]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_justify_interval(interv: Ptr): Ptr {
-	const _r = callPtr('interval_justify_interval_w', [ptrArgType()], [ptrArgVal(interv)]);
+export function timestamptz_extract(tstz: TimestampTz, units: string): number {
+	const _r = call<number>('timestamptz_extract_w', 'number', ['bigint', 'string'], [BigInt(tstz), units]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_larger(interv1: Ptr, interv2: Ptr): Ptr {
-	const _r = callPtr('interval_larger_w', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]);
+export function timestamptz_hash(tstz: TimestampTz): number {
+	const _r = call<number>('timestamptz_hash_w', 'number', ['bigint'], [BigInt(tstz)]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_le(interv1: Ptr, interv2: Ptr): boolean {
-	const _r = call<number>('interval_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0;
+export function timestamptz_hash_extended(tstz: TimestampTz, seed: number): number {
+	const _r = Number(call<bigint>('timestamptz_hash_extended_w', 'bigint', ['bigint', 'bigint'], [BigInt(tstz), BigInt(seed)]));
 	checkMeosError();
 	return _r;
 }
 
-export function interval_lt(interv1: Ptr, interv2: Ptr): boolean {
-	const _r = call<number>('interval_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0;
+export function timestamptz_izone(tstz: TimestampTz, zone: Ptr): number {
+	const _r = call<number>('timestamptz_izone_w', 'number', ['bigint', ptrArgType()], [BigInt(tstz), ptrArgVal(zone)]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_make(years: number, months: number, weeks: number, days: number, hours: number, mins: number, secs: number): Ptr {
-	const _r = callPtr('interval_make_w', ['number', 'number', 'number', 'number', 'number', 'number', 'number'], [years, months, weeks, days, hours, mins, secs]);
+export function timestamptz_make(year: number, month: number, day: number, hour: number, min: number, sec: number): TimestampTz {
+	const _r = call<TimestampTz>('timestamptz_make_w', 'number', ['number', 'number', 'number', 'number', 'number', 'number'], [year, month, day, hour, min, sec]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_ne(interv1: Ptr, interv2: Ptr): boolean {
-	const _r = call<number>('interval_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0;
+export function timestamptz_make_at_timezone(year: number, month: number, day: number, hour: number, min: number, sec: number, zone: string): TimestampTz {
+	const _r = call<TimestampTz>('timestamptz_make_at_timezone_w', 'number', ['number', 'number', 'number', 'number', 'number', 'number', 'string'], [year, month, day, hour, min, sec, zone]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_negate(interv: Ptr): Ptr {
-	const _r = callPtr('interval_negate_w', [ptrArgType()], [ptrArgVal(interv)]);
+export function timestamptz_overlaps(ts1: TimestampTz, te1: TimestampTz, ts2: TimestampTz, te2: TimestampTz): boolean {
+	const _r = call<number>('timestamptz_overlaps_w', 'number', ['bigint', 'bigint', 'bigint', 'bigint'], [BigInt(ts1), BigInt(te1), BigInt(ts2), BigInt(te2)]) !== 0;
 	checkMeosError();
 	return _r;
 }
 
-export function interval_part(interv: Ptr, units: string): number {
-	const _r = call<number>('interval_part_w', 'number', [ptrArgType(), 'string'], [ptrArgVal(interv), units]);
+export function timestamptz_part(tstz: TimestampTz, units: string): number {
+	const _r = call<number>('timestamptz_part_w', 'number', ['bigint', 'string'], [BigInt(tstz), units]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_scale(interv: Ptr, typmod: number): Ptr {
-	const _r = callPtr('interval_scale_w', [ptrArgType(), 'number'], [ptrArgVal(interv), typmod]);
+export function timestamptz_scale(tstz: TimestampTz, typmod: number): TimestampTz {
+	const _r = call<TimestampTz>('timestamptz_scale_w', 'number', ['bigint', 'number'], [BigInt(tstz), typmod]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_smaller(interv1: Ptr, interv2: Ptr): Ptr {
-	const _r = callPtr('interval_smaller_w', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]);
+export function timestamptz_shift(tstz: TimestampTz, interv: Ptr): TimestampTz {
+	const _r = call<TimestampTz>('timestamptz_shift_w', 'number', ['bigint', ptrArgType()], [BigInt(tstz), ptrArgVal(interv)]);
 	checkMeosError();
 	return _r;
 }
 
-export function interval_trunc(interv: Ptr, units: string): Ptr {
-	const _r = callPtr('interval_trunc_w', [ptrArgType(), 'string'], [ptrArgVal(interv), units]);
+export function timestamptz_to_timestamp(tstz: TimestampTz): number {
+	const _r = call<number>('timestamptz_to_timestamp_w', 'number', ['bigint'], [BigInt(tstz)]);
 	checkMeosError();
 	return _r;
 }
 
-export function minus_interval_interval(interv1: Ptr, interv2: Ptr): Ptr {
-	const _r = callPtr('minus_interval_interval_w', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]);
+export function timestamptz_trunc(tstz: TimestampTz, units: string): TimestampTz {
+	const _r = call<TimestampTz>('timestamptz_trunc_w', 'number', ['bigint', 'string'], [BigInt(tstz), units]);
 	checkMeosError();
 	return _r;
 }
 
-export function mul_float8_interval(factor: number, interv: Ptr): Ptr {
-	const _r = callPtr('mul_float8_interval_w', ['number', ptrArgType()], [factor, ptrArgVal(interv)]);
+export function timestamptz_trunc_zone(tstz: TimestampTz, units: string, zone: string): TimestampTz {
+	const _r = call<TimestampTz>('timestamptz_trunc_zone_w', 'number', ['bigint', 'string', 'string'], [BigInt(tstz), units, zone]);
 	checkMeosError();
 	return _r;
 }
 
-export function mul_interval_float8(interv: Ptr, factor: number): Ptr {
-	const _r = callPtr('mul_interval_float8_w', [ptrArgType(), 'number'], [ptrArgVal(interv), factor]);
+export function timestamptz_zone(tstz: TimestampTz, zone: string): number {
+	const _r = call<number>('timestamptz_zone_w', 'number', ['bigint', 'string'], [BigInt(tstz), zone]);
 	checkMeosError();
 	return _r;
 }
diff --git a/core/types/basic/tnumber/TNumber.ts b/core/types/basic/tnumber/TNumber.ts
index 60a8754..e06bf27 100644
--- a/core/types/basic/tnumber/TNumber.ts
+++ b/core/types/basic/tnumber/TNumber.ts
@@ -2,7 +2,6 @@ import { Temporal } from '../../temporal/Temporal.js';
 import type { Ptr } from '../../../functions/functions.generated.js';
 import {
 	tnumber_integral,
-	tnumber_avg_value,
 	tnumber_twavg,
 	tnumber_abs,
 	tnumber_delta_value,
@@ -64,8 +63,6 @@ export abstract class TNumber extends Temporal<number> {
 	/** Returns the time-weighted average. MEOS: tnumber_twavg */
 	timeWeightedAverage(): number { return tnumber_twavg(this._inner); }
 
-	/** Returns the plain average of all instant values. MEOS: tnumber_avg_value */
-	avgValue(): number { return tnumber_avg_value(this._inner); }
 
 	// -------------------------------------------------------------------------
 	// VALUE TRANSFORMATIONS