From 6a1681f42527558ea94f9a8f6812e4d524923398 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20Zim=C3=A1nyi?= <estebanzimanyi@gmail.com>
Date: Sat, 29 Aug 2026 15:00:56 +0200
Subject: [PATCH] Refresh the generated functions snapshot

The committed functions package is what a `go get` consumer compiles,
and it is derived from a catalog of the MEOS headers. Regenerating it
from a catalog derived at MobilityDB b7a0bf712d brings it back to the
surface the library exports: rtree_search, rtree_join and
rtree_search_temporal take IndexSearchOp, the type meos.h declares,
where the snapshot carried the retired RTreeSearchOp spelling in
eighteen places.

The refresh also carries the families the catalog reports today, so the
whole module builds against an all-families libmeos.
---
 functions/meos_meos.go              | 581 +++++++++++++++++++++++++---
 functions/meos_meos_catalog.go      |  46 +++
 functions/meos_meos_cbuffer.go      |   2 +
 functions/meos_meos_geo.go          |  57 +++
 functions/meos_meos_h3.go           | 367 +++++++++++++++---
 functions/meos_meos_internal.go     | 308 ++++++++++++++-
 functions/meos_meos_internal_geo.go | 290 +++++++++++++-
 functions/meos_meos_json.go         |   2 +
 functions/meos_meos_npoint.go       |   2 +
 functions/meos_meos_pointcloud.go   | 294 ++++++++++++++
 functions/meos_meos_pose.go         | 159 +++++++-
 functions/meos_meos_quadbin.go      |  13 +
 functions/meos_meos_rgeo.go         |  85 +++-
 functions/types.go                  |  36 +-
 14 files changed, 2075 insertions(+), 167 deletions(-)

diff --git a/functions/meos_meos.go b/functions/meos_meos.go
index 4d7b2d6..9d2ae8c 100644
--- a/functions/meos_meos.go
+++ b/functions/meos_meos.go
@@ -36,6 +36,7 @@ package functions
 #define gunion_pcpatch_set union_pcpatch_set
 #define gunion_pcpoint_set union_pcpoint_set
 #define gunion_pose_set union_pose_set
+#define gunion_posechain_set union_posechain_set
 #define gunion_set_bigint union_set_bigint
 #define gunion_set_cbuffer union_set_cbuffer
 #define gunion_set_date union_set_date
@@ -47,6 +48,7 @@ package functions
 #define gunion_set_pcpatch union_set_pcpatch
 #define gunion_set_pcpoint union_set_pcpoint
 #define gunion_set_pose union_set_pose
+#define gunion_set_posechain union_set_posechain
 #define gunion_set_set union_set_set
 #define gunion_set_text union_set_text
 #define gunion_set_timestamptz union_set_timestamptz
@@ -85,6 +87,295 @@ import (
 
 var _ = unsafe.Pointer(nil)
 
+// BoolIn wraps MEOS C function bool_in.
+func BoolIn(str string) (_r0 bool, _err error) {
+	_c_str := C.CString(str)
+	defer C.free(unsafe.Pointer(_c_str))
+	C.meos_errno_reset()
+	_cret := C.bool_in(_c_str)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// BoolOut wraps MEOS C function bool_out.
+func BoolOut(b bool) (_r0 string, _err error) {
+	C.meos_errno_reset()
+	_cret := C.bool_out(C.bool(b))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(_cret), nil
+}
+
+
+// Float8Out wraps MEOS C function float8_out.
+func Float8Out(num float64, maxdd int) (_r0 string, _err error) {
+	C.meos_errno_reset()
+	_cret := C.float8_out(C.double(num), C.int(maxdd))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(_cret), nil
+}
+
+
+// DateIn wraps MEOS C function date_in.
+func DateIn(str string) (_r0 int32, _err error) {
+	_c_str := C.CString(str)
+	defer C.free(unsafe.Pointer(_c_str))
+	C.meos_errno_reset()
+	_cret := C.date_in(_c_str)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return int32(_cret), nil
+}
+
+
+// DateOut wraps MEOS C function date_out.
+func DateOut(date int32) (_r0 string, _err error) {
+	C.meos_errno_reset()
+	_cret := C.date_out(C.DateADT(date))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(_cret), nil
+}
+
+
+// IntervalCmp wraps MEOS C function interval_cmp.
+func IntervalCmp(interv1 *Interval, interv2 *Interval) (_r0 int, _err error) {
+	C.meos_errno_reset()
+	_cret := C.interval_cmp(interv1._inner, interv2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return int(_cret), nil
+}
+
+
+// IntervalIn wraps MEOS C function interval_in.
+func IntervalIn(str string, typmod int32) (_r0 *Interval, _err error) {
+	_c_str := C.CString(str)
+	defer C.free(unsafe.Pointer(_c_str))
+	C.meos_errno_reset()
+	_cret := C.interval_in(_c_str, C.int32(typmod))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Interval{_inner: _cret}, nil
+}
+
+
+// IntervalOut wraps MEOS C function interval_out.
+func IntervalOut(interv *Interval) (_r0 string, _err error) {
+	C.meos_errno_reset()
+	_cret := C.interval_out(interv._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(_cret), nil
+}
+
+
+// TimeIn wraps MEOS C function time_in.
+func TimeIn(str string, typmod int32) (_r0 int64, _err error) {
+	_c_str := C.CString(str)
+	defer C.free(unsafe.Pointer(_c_str))
+	C.meos_errno_reset()
+	_cret := C.time_in(_c_str, C.int32(typmod))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return int64(_cret), nil
+}
+
+
+// TimeOut wraps MEOS C function time_out.
+func TimeOut(time int64) (_r0 string, _err error) {
+	C.meos_errno_reset()
+	_cret := C.time_out(C.TimeADT(time))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(_cret), nil
+}
+
+
+// TimestampIn wraps MEOS C function timestamp_in.
+func TimestampIn(str string, typmod int32) (_r0 int64, _err error) {
+	_c_str := C.CString(str)
+	defer C.free(unsafe.Pointer(_c_str))
+	C.meos_errno_reset()
+	_cret := C.timestamp_in(_c_str, C.int32(typmod))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return int64(_cret), nil
+}
+
+
+// TimestampOut wraps MEOS C function timestamp_out.
+func TimestampOut(ts int64) (_r0 string, _err error) {
+	C.meos_errno_reset()
+	_cret := C.timestamp_out(C.Timestamp(ts))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(_cret), nil
+}
+
+
+// TimestamptzIn wraps MEOS C function timestamptz_in.
+func TimestamptzIn(str string, typmod int32) (_r0 int64, _err error) {
+	_c_str := C.CString(str)
+	defer C.free(unsafe.Pointer(_c_str))
+	C.meos_errno_reset()
+	_cret := C.timestamptz_in(_c_str, C.int32(typmod))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return int64(_cret), nil
+}
+
+
+// TimestamptzOut wraps MEOS C function timestamptz_out.
+func TimestamptzOut(tstz int64) (_r0 string, _err error) {
+	C.meos_errno_reset()
+	_cret := C.timestamptz_out(C.TimestampTz(tstz))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(_cret), nil
+}
+
+
+// CstringToText wraps MEOS C function cstring_to_text.
+func CstringToText(str string) (_r0 string, _err error) {
+	_c_str := C.CString(str)
+	defer C.free(unsafe.Pointer(_c_str))
+	C.meos_errno_reset()
+	_cret := C.cstring_to_text(_c_str)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(C.text_to_cstring(_cret)), nil
+}
+
+
+// TextToCstring wraps MEOS C function text_to_cstring.
+func TextToCstring(txt string) (_r0 string, _err error) {
+	_c_txt := C.cstring_to_text(C.CString(txt))
+	defer C.free(unsafe.Pointer(_c_txt))
+	C.meos_errno_reset()
+	_cret := C.text_to_cstring(_c_txt)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(_cret), nil
+}
+
+
+// TextIn wraps MEOS C function text_in.
+func TextIn(str string) (_r0 string, _err error) {
+	_c_str := C.CString(str)
+	defer C.free(unsafe.Pointer(_c_str))
+	C.meos_errno_reset()
+	_cret := C.text_in(_c_str)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(C.text_to_cstring(_cret)), nil
+}
+
+
+// TextOut wraps MEOS C function text_out.
+func TextOut(txt string) (_r0 string, _err error) {
+	_c_txt := C.cstring_to_text(C.CString(txt))
+	defer C.free(unsafe.Pointer(_c_txt))
+	C.meos_errno_reset()
+	_cret := C.text_out(_c_txt)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(_cret), nil
+}
+
+
+// TODO text_cmp: unsupported param Oid
+// func TextCmp(...) { /* not yet handled by codegen */ }
+
+
+// TextCopy wraps MEOS C function text_copy.
+func TextCopy(txt string) (_r0 string, _err error) {
+	_c_txt := C.cstring_to_text(C.CString(txt))
+	defer C.free(unsafe.Pointer(_c_txt))
+	C.meos_errno_reset()
+	_cret := C.text_copy(_c_txt)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(C.text_to_cstring(_cret)), nil
+}
+
+
+// TextInitcap wraps MEOS C function text_initcap.
+func TextInitcap(txt string) (_r0 string, _err error) {
+	_c_txt := C.cstring_to_text(C.CString(txt))
+	defer C.free(unsafe.Pointer(_c_txt))
+	C.meos_errno_reset()
+	_cret := C.text_initcap(_c_txt)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(C.text_to_cstring(_cret)), nil
+}
+
+
+// TextLower wraps MEOS C function text_lower.
+func TextLower(txt string) (_r0 string, _err error) {
+	_c_txt := C.cstring_to_text(C.CString(txt))
+	defer C.free(unsafe.Pointer(_c_txt))
+	C.meos_errno_reset()
+	_cret := C.text_lower(_c_txt)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(C.text_to_cstring(_cret)), nil
+}
+
+
+// TextUpper wraps MEOS C function text_upper.
+func TextUpper(txt string) (_r0 string, _err error) {
+	_c_txt := C.cstring_to_text(C.CString(txt))
+	defer C.free(unsafe.Pointer(_c_txt))
+	C.meos_errno_reset()
+	_cret := C.text_upper(_c_txt)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(C.text_to_cstring(_cret)), nil
+}
+
+
+// TextcatTextText wraps MEOS C function textcat_text_text.
+func TextcatTextText(txt1 string, txt2 string) (_r0 string, _err error) {
+	_c_txt1 := C.cstring_to_text(C.CString(txt1))
+	defer C.free(unsafe.Pointer(_c_txt1))
+	_c_txt2 := C.cstring_to_text(C.CString(txt2))
+	defer C.free(unsafe.Pointer(_c_txt2))
+	C.meos_errno_reset()
+	_cret := C.textcat_text_text(_c_txt1, _c_txt2)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(C.text_to_cstring(_cret)), nil
+}
+
+
 // MeosArrayCreate wraps MEOS C function meos_array_create.
 func MeosArrayCreate(elem_size int) (_r0 *MeosArray, _err error) {
 	C.meos_errno_reset()
@@ -272,87 +563,99 @@ func RtreeFree(rtree *RTree) (_err error) {
 }
 
 
-// RtreeInsert wraps MEOS C function rtree_insert.
-func RtreeInsert(rtree *RTree, box unsafe.Pointer, id int) (_err error) {
+// RtreeNumEntries wraps MEOS C function rtree_num_entries.
+func RtreeNumEntries(rtree *RTree) (_r0 int, _err error) {
 	C.meos_errno_reset()
-	C.rtree_insert(rtree._inner, unsafe.Pointer(box), C.int(id))
+	_cret := C.rtree_num_entries(rtree._inner)
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return nil
+	return int(_cret), nil
 }
 
 
-// RtreeInsertTemporal wraps MEOS C function rtree_insert_temporal.
-func RtreeInsertTemporal(rtree *RTree, temp *Temporal, id int) (_err error) {
+// RtreeMemSize wraps MEOS C function rtree_mem_size.
+func RtreeMemSize(rtree *RTree) (_r0 int64, _err error) {
 	C.meos_errno_reset()
-	C.rtree_insert_temporal(rtree._inner, temp._inner, C.int(id))
+	_cret := C.rtree_mem_size(rtree._inner)
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return nil
+	return int64(_cret), nil
 }
 
 
-// RtreeInsertTemporalSplit wraps MEOS C function rtree_insert_temporal_split.
-func RtreeInsertTemporalSplit(rtree *RTree, temp *Temporal, id int, maxboxes int) (_err error) {
+// RtreeHeight wraps MEOS C function rtree_height.
+func RtreeHeight(rtree *RTree) (_r0 int, _err error) {
 	C.meos_errno_reset()
-	C.rtree_insert_temporal_split(rtree._inner, temp._inner, C.int(id), C.int(maxboxes))
+	_cret := C.rtree_height(rtree._inner)
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return nil
+	return int(_cret), nil
 }
 
 
-// RtreeSearch wraps MEOS C function rtree_search.
-func RtreeSearch(rtree *RTree, op RTreeSearchOp, query unsafe.Pointer) (_r0 int, _r1 *MeosArray, _err error) {
-	var _out_result C.MeosArray
+// RtreeInsert wraps MEOS C function rtree_insert.
+func RtreeInsert(rtree *RTree, box unsafe.Pointer, id int64) (_r0 bool, _err error) {
 	C.meos_errno_reset()
-	_cret := C.rtree_search(rtree._inner, C.RTreeSearchOp(op), unsafe.Pointer(query), &_out_result)
+	_cret := C.rtree_insert(rtree._inner, unsafe.Pointer(box), C.int64_t(id))
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return int(_cret), &MeosArray{_inner: &_out_result}, nil
+	return bool(_cret), nil
 }
 
 
-// RtreeJoin wraps MEOS C function rtree_join.
-func RtreeJoin(rtree1 *RTree, rtree2 *RTree, op RTreeSearchOp) (_r0 int, _r1 *MeosArray, _err error) {
-	var _out_result C.MeosArray
+// RtreeLoad wraps MEOS C function rtree_load.
+func RtreeLoad(rtree *RTree, boxes unsafe.Pointer, ids unsafe.Pointer, count int) (_r0 bool, _err error) {
 	C.meos_errno_reset()
-	_cret := C.rtree_join(rtree1._inner, rtree2._inner, C.RTreeSearchOp(op), &_out_result)
+	_cret := C.rtree_load(rtree._inner, unsafe.Pointer(boxes), (*C.int64_t)(unsafe.Pointer(ids)), C.int(count))
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return int(_cret), &MeosArray{_inner: &_out_result}, nil
+	return bool(_cret), nil
 }
 
 
-// RtreeSearchTemporal wraps MEOS C function rtree_search_temporal.
-func RtreeSearchTemporal(rtree *RTree, op RTreeSearchOp, temp *Temporal) (_r0 int, _r1 *MeosArray, _err error) {
-	var _out_result C.MeosArray
+// RtreeInsertTemporal wraps MEOS C function rtree_insert_temporal.
+func RtreeInsertTemporal(rtree *RTree, temp *Temporal, id int64) (_r0 bool, _err error) {
 	C.meos_errno_reset()
-	_cret := C.rtree_search_temporal(rtree._inner, C.RTreeSearchOp(op), temp._inner, &_out_result)
+	_cret := C.rtree_insert_temporal(rtree._inner, temp._inner, C.int64_t(id))
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return int(_cret), &MeosArray{_inner: &_out_result}, nil
+	return bool(_cret), nil
 }
 
 
-// RtreeSearchTemporalDedup wraps MEOS C function rtree_search_temporal_dedup.
-func RtreeSearchTemporalDedup(rtree *RTree, op RTreeSearchOp, temp *Temporal, maxboxes int) (_r0 int, _r1 *MeosArray, _err error) {
-	var _out_result C.MeosArray
+// RtreeInsertTemporalSplit wraps MEOS C function rtree_insert_temporal_split.
+func RtreeInsertTemporalSplit(rtree *RTree, temp *Temporal, id int64, maxboxes int) (_r0 bool, _err error) {
 	C.meos_errno_reset()
-	_cret := C.rtree_search_temporal_dedup(rtree._inner, C.RTreeSearchOp(op), temp._inner, C.int(maxboxes), &_out_result)
+	_cret := C.rtree_insert_temporal_split(rtree._inner, temp._inner, C.int64_t(id), C.int(maxboxes))
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return int(_cret), &MeosArray{_inner: &_out_result}, nil
+	return bool(_cret), nil
 }
 
 
+// TODO rtree_search: unsupported param IndexSearchOp
+// func RtreeSearch(...) { /* not yet handled by codegen */ }
+
+
+// TODO rtree_join: unsupported param IndexSearchOp
+// func RtreeJoin(...) { /* not yet handled by codegen */ }
+
+
+// TODO rtree_search_temporal: unsupported param IndexSearchOp
+// func RtreeSearchTemporal(...) { /* not yet handled by codegen */ }
+
+
+// TODO rtree_search_temporal_dedup: unsupported param IndexSearchOp
+// func RtreeSearchTemporalDedup(...) { /* not yet handled by codegen */ }
+
+
 // RtreeNnCursorOpen wraps MEOS C function rtree_nn_cursor_open.
 func RtreeNnCursorOpen(rtree *RTree, query unsafe.Pointer) (_r0 unsafe.Pointer, _err error) {
 	C.meos_errno_reset()
@@ -367,7 +670,7 @@ func RtreeNnCursorOpen(rtree *RTree, query unsafe.Pointer) (_r0 unsafe.Pointer,
 // RtreeNnCursorNext wraps MEOS C function rtree_nn_cursor_next.
 func RtreeNnCursorNext(cursor unsafe.Pointer, id_out unsafe.Pointer, dist_out unsafe.Pointer) (_r0 bool, _err error) {
 	C.meos_errno_reset()
-	_cret := C.rtree_nn_cursor_next((*C.RTreeNNCursor)(unsafe.Pointer(cursor)), (*C.int)(unsafe.Pointer(id_out)), (*C.double)(unsafe.Pointer(dist_out)))
+	_cret := C.rtree_nn_cursor_next((*C.RTreeNNCursor)(unsafe.Pointer(cursor)), (*C.int64_t)(unsafe.Pointer(id_out)), (*C.double)(unsafe.Pointer(dist_out)))
 	if _err = meosError(); _err != nil {
 		return
 	}
@@ -429,75 +732,99 @@ func SptreeFree(sptree unsafe.Pointer) (_err error) {
 }
 
 
-// SptreeInsert wraps MEOS C function sptree_insert.
-func SptreeInsert(sptree unsafe.Pointer, box unsafe.Pointer, id int) (_err error) {
+// SptreeNumEntries wraps MEOS C function sptree_num_entries.
+func SptreeNumEntries(sptree unsafe.Pointer) (_r0 int, _err error) {
 	C.meos_errno_reset()
-	C.sptree_insert((*C.SPTree)(unsafe.Pointer(sptree)), unsafe.Pointer(box), C.int(id))
+	_cret := C.sptree_num_entries((*C.SPTree)(unsafe.Pointer(sptree)))
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return nil
+	return int(_cret), nil
 }
 
 
-// SptreeInsertTemporal wraps MEOS C function sptree_insert_temporal.
-func SptreeInsertTemporal(sptree unsafe.Pointer, temp *Temporal, id int) (_err error) {
+// SptreeMemSize wraps MEOS C function sptree_mem_size.
+func SptreeMemSize(sptree unsafe.Pointer) (_r0 int64, _err error) {
 	C.meos_errno_reset()
-	C.sptree_insert_temporal((*C.SPTree)(unsafe.Pointer(sptree)), temp._inner, C.int(id))
+	_cret := C.sptree_mem_size((*C.SPTree)(unsafe.Pointer(sptree)))
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return nil
+	return int64(_cret), nil
 }
 
 
-// SptreeInsertTemporalSplit wraps MEOS C function sptree_insert_temporal_split.
-func SptreeInsertTemporalSplit(sptree unsafe.Pointer, temp *Temporal, id int, maxboxes int) (_err error) {
+// SptreeHeight wraps MEOS C function sptree_height.
+func SptreeHeight(sptree unsafe.Pointer) (_r0 int, _err error) {
 	C.meos_errno_reset()
-	C.sptree_insert_temporal_split((*C.SPTree)(unsafe.Pointer(sptree)), temp._inner, C.int(id), C.int(maxboxes))
+	_cret := C.sptree_height((*C.SPTree)(unsafe.Pointer(sptree)))
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return nil
+	return int(_cret), nil
 }
 
 
-// SptreeSearch wraps MEOS C function sptree_search.
-func SptreeSearch(sptree unsafe.Pointer, op RTreeSearchOp, query unsafe.Pointer) (_r0 int, _r1 *MeosArray, _err error) {
-	var _out_result C.MeosArray
+// SptreeInsert wraps MEOS C function sptree_insert.
+func SptreeInsert(sptree unsafe.Pointer, box unsafe.Pointer, id int64) (_r0 bool, _err error) {
 	C.meos_errno_reset()
-	_cret := C.sptree_search((*C.SPTree)(unsafe.Pointer(sptree)), C.RTreeSearchOp(op), unsafe.Pointer(query), &_out_result)
+	_cret := C.sptree_insert((*C.SPTree)(unsafe.Pointer(sptree)), unsafe.Pointer(box), C.int64_t(id))
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return int(_cret), &MeosArray{_inner: &_out_result}, nil
+	return bool(_cret), nil
 }
 
 
-// SptreeSearchTemporal wraps MEOS C function sptree_search_temporal.
-func SptreeSearchTemporal(sptree unsafe.Pointer, op RTreeSearchOp, temp *Temporal) (_r0 int, _r1 *MeosArray, _err error) {
-	var _out_result C.MeosArray
+// SptreeLoad wraps MEOS C function sptree_load.
+func SptreeLoad(sptree unsafe.Pointer, boxes unsafe.Pointer, ids unsafe.Pointer, count int) (_r0 bool, _err error) {
 	C.meos_errno_reset()
-	_cret := C.sptree_search_temporal((*C.SPTree)(unsafe.Pointer(sptree)), C.RTreeSearchOp(op), temp._inner, &_out_result)
+	_cret := C.sptree_load((*C.SPTree)(unsafe.Pointer(sptree)), unsafe.Pointer(boxes), (*C.int64_t)(unsafe.Pointer(ids)), C.int(count))
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return int(_cret), &MeosArray{_inner: &_out_result}, nil
+	return bool(_cret), nil
 }
 
 
-// SptreeSearchTemporalDedup wraps MEOS C function sptree_search_temporal_dedup.
-func SptreeSearchTemporalDedup(sptree unsafe.Pointer, op RTreeSearchOp, temp *Temporal, maxboxes int) (_r0 int, _r1 *MeosArray, _err error) {
-	var _out_result C.MeosArray
+// SptreeInsertTemporal wraps MEOS C function sptree_insert_temporal.
+func SptreeInsertTemporal(sptree unsafe.Pointer, temp *Temporal, id int64) (_r0 bool, _err error) {
 	C.meos_errno_reset()
-	_cret := C.sptree_search_temporal_dedup((*C.SPTree)(unsafe.Pointer(sptree)), C.RTreeSearchOp(op), temp._inner, C.int(maxboxes), &_out_result)
+	_cret := C.sptree_insert_temporal((*C.SPTree)(unsafe.Pointer(sptree)), temp._inner, C.int64_t(id))
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return int(_cret), &MeosArray{_inner: &_out_result}, nil
+	return bool(_cret), nil
 }
 
 
+// SptreeInsertTemporalSplit wraps MEOS C function sptree_insert_temporal_split.
+func SptreeInsertTemporalSplit(sptree unsafe.Pointer, temp *Temporal, id int64, maxboxes int) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.sptree_insert_temporal_split((*C.SPTree)(unsafe.Pointer(sptree)), temp._inner, C.int64_t(id), C.int(maxboxes))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// TODO sptree_search: unsupported param IndexSearchOp
+// func SptreeSearch(...) { /* not yet handled by codegen */ }
+
+
+// TODO sptree_join: unsupported param IndexSearchOp
+// func SptreeJoin(...) { /* not yet handled by codegen */ }
+
+
+// TODO sptree_search_temporal: unsupported param IndexSearchOp
+// func SptreeSearchTemporal(...) { /* not yet handled by codegen */ }
+
+
+// TODO sptree_search_temporal_dedup: unsupported param IndexSearchOp
+// func SptreeSearchTemporalDedup(...) { /* not yet handled by codegen */ }
+
+
 // SptreeNnCursorOpen wraps MEOS C function sptree_nn_cursor_open.
 func SptreeNnCursorOpen(sptree unsafe.Pointer, query unsafe.Pointer) (_r0 unsafe.Pointer, _err error) {
 	C.meos_errno_reset()
@@ -512,7 +839,7 @@ func SptreeNnCursorOpen(sptree unsafe.Pointer, query unsafe.Pointer) (_r0 unsafe
 // SptreeNnCursorNext wraps MEOS C function sptree_nn_cursor_next.
 func SptreeNnCursorNext(cursor unsafe.Pointer, id_out unsafe.Pointer, dist_out unsafe.Pointer) (_r0 bool, _err error) {
 	C.meos_errno_reset()
-	_cret := C.sptree_nn_cursor_next((*C.SPNNCursor)(unsafe.Pointer(cursor)), (*C.int)(unsafe.Pointer(id_out)), (*C.double)(unsafe.Pointer(dist_out)))
+	_cret := C.sptree_nn_cursor_next((*C.SPNNCursor)(unsafe.Pointer(cursor)), (*C.int64_t)(unsafe.Pointer(id_out)), (*C.double)(unsafe.Pointer(dist_out)))
 	if _err = meosError(); _err != nil {
 		return
 	}
@@ -12166,6 +12493,17 @@ func EverNeTtextText(temp *Temporal, txt string) (_r0 int, _err error) {
 }
 
 
+// TeqBigintTbigint wraps MEOS C function teq_bigint_tbigint.
+func TeqBigintTbigint(i int64, temp *Temporal) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.teq_bigint_tbigint(C.int64_t(i), temp._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TeqBoolTbool wraps MEOS C function teq_bool_tbool.
 func TeqBoolTbool(b bool, temp *Temporal) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -12199,6 +12537,17 @@ func TeqIntTint(i int, temp *Temporal) (_r0 *Temporal, _err error) {
 }
 
 
+// TeqTbigintBigint wraps MEOS C function teq_tbigint_bigint.
+func TeqTbigintBigint(temp *Temporal, i int64) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.teq_tbigint_bigint(temp._inner, C.int64_t(i))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TeqTboolBool wraps MEOS C function teq_tbool_bool.
 func TeqTboolBool(temp *Temporal, b bool) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -12269,6 +12618,17 @@ func TeqTtextText(temp *Temporal, txt string) (_r0 *Temporal, _err error) {
 }
 
 
+// TgeBigintTbigint wraps MEOS C function tge_bigint_tbigint.
+func TgeBigintTbigint(i int64, temp *Temporal) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tge_bigint_tbigint(C.int64_t(i), temp._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TgeFloatTfloat wraps MEOS C function tge_float_tfloat.
 func TgeFloatTfloat(d float64, temp *Temporal) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -12315,6 +12675,17 @@ func TgeTextTtext(txt string, temp *Temporal) (_r0 *Temporal, _err error) {
 }
 
 
+// TgeTbigintBigint wraps MEOS C function tge_tbigint_bigint.
+func TgeTbigintBigint(temp *Temporal, i int64) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tge_tbigint_bigint(temp._inner, C.int64_t(i))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TgeTfloatFloat wraps MEOS C function tge_tfloat_float.
 func TgeTfloatFloat(temp *Temporal, d float64) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -12350,6 +12721,17 @@ func TgeTtextText(temp *Temporal, txt string) (_r0 *Temporal, _err error) {
 }
 
 
+// TgtBigintTbigint wraps MEOS C function tgt_bigint_tbigint.
+func TgtBigintTbigint(i int64, temp *Temporal) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tgt_bigint_tbigint(C.int64_t(i), temp._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TgtFloatTfloat wraps MEOS C function tgt_float_tfloat.
 func TgtFloatTfloat(d float64, temp *Temporal) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -12396,6 +12778,17 @@ func TgtTextTtext(txt string, temp *Temporal) (_r0 *Temporal, _err error) {
 }
 
 
+// TgtTbigintBigint wraps MEOS C function tgt_tbigint_bigint.
+func TgtTbigintBigint(temp *Temporal, i int64) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tgt_tbigint_bigint(temp._inner, C.int64_t(i))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TgtTfloatFloat wraps MEOS C function tgt_tfloat_float.
 func TgtTfloatFloat(temp *Temporal, d float64) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -12431,6 +12824,17 @@ func TgtTtextText(temp *Temporal, txt string) (_r0 *Temporal, _err error) {
 }
 
 
+// TleBigintTbigint wraps MEOS C function tle_bigint_tbigint.
+func TleBigintTbigint(i int64, temp *Temporal) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tle_bigint_tbigint(C.int64_t(i), temp._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TleFloatTfloat wraps MEOS C function tle_float_tfloat.
 func TleFloatTfloat(d float64, temp *Temporal) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -12477,6 +12881,17 @@ func TleTextTtext(txt string, temp *Temporal) (_r0 *Temporal, _err error) {
 }
 
 
+// TleTbigintBigint wraps MEOS C function tle_tbigint_bigint.
+func TleTbigintBigint(temp *Temporal, i int64) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tle_tbigint_bigint(temp._inner, C.int64_t(i))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TleTfloatFloat wraps MEOS C function tle_tfloat_float.
 func TleTfloatFloat(temp *Temporal, d float64) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -12512,6 +12927,17 @@ func TleTtextText(temp *Temporal, txt string) (_r0 *Temporal, _err error) {
 }
 
 
+// TltBigintTbigint wraps MEOS C function tlt_bigint_tbigint.
+func TltBigintTbigint(i int64, temp *Temporal) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tlt_bigint_tbigint(C.int64_t(i), temp._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TltFloatTfloat wraps MEOS C function tlt_float_tfloat.
 func TltFloatTfloat(d float64, temp *Temporal) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -12558,6 +12984,17 @@ func TltTextTtext(txt string, temp *Temporal) (_r0 *Temporal, _err error) {
 }
 
 
+// TltTbigintBigint wraps MEOS C function tlt_tbigint_bigint.
+func TltTbigintBigint(temp *Temporal, i int64) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tlt_tbigint_bigint(temp._inner, C.int64_t(i))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TltTfloatFloat wraps MEOS C function tlt_tfloat_float.
 func TltTfloatFloat(temp *Temporal, d float64) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -12593,6 +13030,17 @@ func TltTtextText(temp *Temporal, txt string) (_r0 *Temporal, _err error) {
 }
 
 
+// TneBigintTbigint wraps MEOS C function tne_bigint_tbigint.
+func TneBigintTbigint(i int64, temp *Temporal) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tne_bigint_tbigint(C.int64_t(i), temp._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TneBoolTbool wraps MEOS C function tne_bool_tbool.
 func TneBoolTbool(b bool, temp *Temporal) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -12626,6 +13074,17 @@ func TneIntTint(i int, temp *Temporal) (_r0 *Temporal, _err error) {
 }
 
 
+// TneTbigintBigint wraps MEOS C function tne_tbigint_bigint.
+func TneTbigintBigint(temp *Temporal, i int64) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tne_tbigint_bigint(temp._inner, C.int64_t(i))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TneTboolBool wraps MEOS C function tne_tbool_bool.
 func TneTboolBool(temp *Temporal, b bool) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
diff --git a/functions/meos_meos_catalog.go b/functions/meos_meos_catalog.go
index 8d510f8..8aa924b 100644
--- a/functions/meos_meos_catalog.go
+++ b/functions/meos_meos_catalog.go
@@ -36,6 +36,7 @@ package functions
 #define gunion_pcpatch_set union_pcpatch_set
 #define gunion_pcpoint_set union_pcpoint_set
 #define gunion_pose_set union_pose_set
+#define gunion_posechain_set union_posechain_set
 #define gunion_set_bigint union_set_bigint
 #define gunion_set_cbuffer union_set_cbuffer
 #define gunion_set_date union_set_date
@@ -47,6 +48,7 @@ package functions
 #define gunion_set_pcpatch union_set_pcpatch
 #define gunion_set_pcpoint union_set_pcpoint
 #define gunion_set_pose union_set_pose
+#define gunion_set_posechain union_set_posechain
 #define gunion_set_set union_set_set
 #define gunion_set_text union_set_text
 #define gunion_set_timestamptz union_set_timestamptz
@@ -566,6 +568,17 @@ func TypeSpanBbox(type_ MeosType) (_r0 bool, _err error) {
 }
 
 
+// TypeBboxtype wraps MEOS C function type_bboxtype.
+func TypeBboxtype(type_ MeosType) (_r0 MeosType, _err error) {
+	C.meos_errno_reset()
+	_cret := C.type_bboxtype(C.MeosType(type_))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return MeosType(_cret), nil
+}
+
+
 // SpanTBOXType wraps MEOS C function span_tbox_type.
 func SpanTBOXType(type_ MeosType) (_r0 bool, _err error) {
 	C.meos_errno_reset()
@@ -786,6 +799,28 @@ func EnsureTnumberType(type_ MeosType) (_r0 bool, _err error) {
 }
 
 
+// TorderType wraps MEOS C function torder_type.
+func TorderType(type_ MeosType) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.torder_type(C.MeosType(type_))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// EnsureTorderType wraps MEOS C function ensure_torder_type.
+func EnsureTorderType(type_ MeosType) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.ensure_torder_type(C.MeosType(type_))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
 // EnsureTnumberBasetype wraps MEOS C function ensure_tnumber_basetype.
 func EnsureTnumberBasetype(type_ MeosType) (_r0 bool, _err error) {
 	C.meos_errno_reset()
@@ -885,6 +920,17 @@ func EnsureTgeoType(type_ MeosType) (_r0 bool, _err error) {
 }
 
 
+// TspatialBodyType wraps MEOS C function tspatial_body_type.
+func TspatialBodyType(type_ MeosType) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tspatial_body_type(C.MeosType(type_))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
 // TgeoTypeAll wraps MEOS C function tgeo_type_all.
 func TgeoTypeAll(type_ MeosType) (_r0 bool, _err error) {
 	C.meos_errno_reset()
diff --git a/functions/meos_meos_cbuffer.go b/functions/meos_meos_cbuffer.go
index 44e5713..6ddcdf5 100644
--- a/functions/meos_meos_cbuffer.go
+++ b/functions/meos_meos_cbuffer.go
@@ -36,6 +36,7 @@ package functions
 #define gunion_pcpatch_set union_pcpatch_set
 #define gunion_pcpoint_set union_pcpoint_set
 #define gunion_pose_set union_pose_set
+#define gunion_posechain_set union_posechain_set
 #define gunion_set_bigint union_set_bigint
 #define gunion_set_cbuffer union_set_cbuffer
 #define gunion_set_date union_set_date
@@ -47,6 +48,7 @@ package functions
 #define gunion_set_pcpatch union_set_pcpatch
 #define gunion_set_pcpoint union_set_pcpoint
 #define gunion_set_pose union_set_pose
+#define gunion_set_posechain union_set_posechain
 #define gunion_set_set union_set_set
 #define gunion_set_text union_set_text
 #define gunion_set_timestamptz union_set_timestamptz
diff --git a/functions/meos_meos_geo.go b/functions/meos_meos_geo.go
index bcc6e69..9338273 100644
--- a/functions/meos_meos_geo.go
+++ b/functions/meos_meos_geo.go
@@ -36,6 +36,7 @@ package functions
 #define gunion_pcpatch_set union_pcpatch_set
 #define gunion_pcpoint_set union_pcpoint_set
 #define gunion_pose_set union_pose_set
+#define gunion_posechain_set union_posechain_set
 #define gunion_set_bigint union_set_bigint
 #define gunion_set_cbuffer union_set_cbuffer
 #define gunion_set_date union_set_date
@@ -47,6 +48,7 @@ package functions
 #define gunion_set_pcpatch union_set_pcpatch
 #define gunion_set_pcpoint union_set_pcpoint
 #define gunion_set_pose union_set_pose
+#define gunion_set_posechain union_set_posechain
 #define gunion_set_set union_set_set
 #define gunion_set_text union_set_text
 #define gunion_set_timestamptz union_set_timestamptz
@@ -682,6 +684,17 @@ func GeomArrayUnion(gsarr unsafe.Pointer, count int) (_r0 *Geom, _err error) {
 }
 
 
+// GeogArrayUnion wraps MEOS C function geog_array_union.
+func GeogArrayUnion(gsarr unsafe.Pointer, count int) (_r0 *Geom, _err error) {
+	C.meos_errno_reset()
+	_cret := C.geog_array_union((**C.GSERIALIZED)(unsafe.Pointer(gsarr)), C.int(count))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Geom{_inner: _cret}, nil
+}
+
+
 // GeomBoundary wraps MEOS C function geom_boundary.
 func GeomBoundary(gs *Geom) (_r0 *Geom, _err error) {
 	C.meos_errno_reset()
@@ -739,6 +752,17 @@ func GeomDifference2d(gs1 *Geom, gs2 *Geom) (_r0 *Geom, _err error) {
 }
 
 
+// GeomIsSimple wraps MEOS C function geom_is_simple.
+func GeomIsSimple(gs *Geom) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.geom_is_simple(gs._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
 // GeomIntersection2d wraps MEOS C function geom_intersection2d.
 func GeomIntersection2d(gs1 *Geom, gs2 *Geom) (_r0 *Geom, _err error) {
 	C.meos_errno_reset()
@@ -772,6 +796,17 @@ func GeomMinBoundingRadius(geom *Geom, radius unsafe.Pointer) (_r0 *Geom, _err e
 }
 
 
+// GeomOrientedEnvelope wraps MEOS C function geom_oriented_envelope.
+func GeomOrientedEnvelope(gs *Geom) (_r0 *Geom, _err error) {
+	C.meos_errno_reset()
+	_cret := C.geom_oriented_envelope(gs._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Geom{_inner: _cret}, nil
+}
+
+
 // GeomShortestline2d wraps MEOS C function geom_shortestline2d.
 func GeomShortestline2d(gs1 *Geom, gs2 *Geom) (_r0 *Geom, _err error) {
 	C.meos_errno_reset()
@@ -959,6 +994,17 @@ func GeomIntersects3d(gs1 *Geom, gs2 *Geom) (_r0 bool, _err error) {
 }
 
 
+// GeomRelate wraps MEOS C function geom_relate.
+func GeomRelate(gs1 *Geom, gs2 *Geom) (_r0 string, _err error) {
+	C.meos_errno_reset()
+	_cret := C.geom_relate(gs1._inner, gs2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(_cret), nil
+}
+
+
 // GeomRelatePattern wraps MEOS C function geom_relate_pattern.
 func GeomRelatePattern(gs1 *Geom, gs2 *Geom, patt string) (_r0 bool, _err error) {
 	_c_patt := C.CString(patt)
@@ -1038,6 +1084,17 @@ func GeomDistance2d(gs1 *Geom, gs2 *Geom) (_r0 float64, _err error) {
 }
 
 
+// GeomMaxDistance2d wraps MEOS C function geom_max_distance2d.
+func GeomMaxDistance2d(gs1 *Geom, gs2 *Geom) (_r0 float64, _err error) {
+	C.meos_errno_reset()
+	_cret := C.geom_max_distance2d(gs1._inner, gs2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return float64(_cret), nil
+}
+
+
 // GeomDistance3d wraps MEOS C function geom_distance3d.
 func GeomDistance3d(gs1 *Geom, gs2 *Geom) (_r0 float64, _err error) {
 	C.meos_errno_reset()
diff --git a/functions/meos_meos_h3.go b/functions/meos_meos_h3.go
index 5f22888..11f4718 100644
--- a/functions/meos_meos_h3.go
+++ b/functions/meos_meos_h3.go
@@ -36,6 +36,7 @@ package functions
 #define gunion_pcpatch_set union_pcpatch_set
 #define gunion_pcpoint_set union_pcpoint_set
 #define gunion_pose_set union_pose_set
+#define gunion_posechain_set union_posechain_set
 #define gunion_set_bigint union_set_bigint
 #define gunion_set_cbuffer union_set_cbuffer
 #define gunion_set_date union_set_date
@@ -47,6 +48,7 @@ package functions
 #define gunion_set_pcpatch union_set_pcpatch
 #define gunion_set_pcpoint union_set_pcpoint
 #define gunion_set_pose union_set_pose
+#define gunion_set_posechain union_set_posechain
 #define gunion_set_set union_set_set
 #define gunion_set_text union_set_text
 #define gunion_set_timestamptz union_set_timestamptz
@@ -85,6 +87,250 @@ import (
 
 var _ = unsafe.Pointer(nil)
 
+// H3indexIn wraps MEOS C function h3index_in.
+func H3indexIn(str string) (_r0 uint64, _err error) {
+	_c_str := C.CString(str)
+	defer C.free(unsafe.Pointer(_c_str))
+	C.meos_errno_reset()
+	_cret := C.h3index_in(_c_str)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return uint64(_cret), nil
+}
+
+
+// H3indexOut wraps MEOS C function h3index_out.
+func H3indexOut(cell uint64) (_r0 string, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3index_out(C.uint64_t(cell))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(_cret), nil
+}
+
+
+// H3IsValidCell wraps MEOS C function h3_is_valid_cell.
+func H3IsValidCell(cell uint64) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3_is_valid_cell(C.uint64_t(cell))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// H3IsValidDirectedEdge wraps MEOS C function h3_is_valid_directed_edge.
+func H3IsValidDirectedEdge(edge uint64) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3_is_valid_directed_edge(C.uint64_t(edge))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// H3IsValidVertex wraps MEOS C function h3_is_valid_vertex.
+func H3IsValidVertex(vertex uint64) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3_is_valid_vertex(C.uint64_t(vertex))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// H3indexEq wraps MEOS C function h3index_eq.
+func H3indexEq(a uint64, b uint64) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3index_eq(C.uint64_t(a), C.uint64_t(b))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// H3indexNe wraps MEOS C function h3index_ne.
+func H3indexNe(a uint64, b uint64) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3index_ne(C.uint64_t(a), C.uint64_t(b))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// H3indexLt wraps MEOS C function h3index_lt.
+func H3indexLt(a uint64, b uint64) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3index_lt(C.uint64_t(a), C.uint64_t(b))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// H3indexLe wraps MEOS C function h3index_le.
+func H3indexLe(a uint64, b uint64) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3index_le(C.uint64_t(a), C.uint64_t(b))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// H3indexGt wraps MEOS C function h3index_gt.
+func H3indexGt(a uint64, b uint64) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3index_gt(C.uint64_t(a), C.uint64_t(b))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// H3indexGe wraps MEOS C function h3index_ge.
+func H3indexGe(a uint64, b uint64) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3index_ge(C.uint64_t(a), C.uint64_t(b))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// H3indexCmp wraps MEOS C function h3index_cmp.
+func H3indexCmp(a uint64, b uint64) (_r0 int, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3index_cmp(C.uint64_t(a), C.uint64_t(b))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return int(_cret), nil
+}
+
+
+// H3indexHash wraps MEOS C function h3index_hash.
+func H3indexHash(cell uint64) (_r0 uint32, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3index_hash(C.uint64_t(cell))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return uint32(_cret), nil
+}
+
+
+// H3GridDisk wraps MEOS C function h3_grid_disk.
+func H3GridDisk(origin uint64, k int) (_r0 *Set, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3_grid_disk(C.uint64_t(origin), C.int(k))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Set{_inner: _cret}, nil
+}
+
+
+// H3CellToChildren wraps MEOS C function h3_cell_to_children.
+func H3CellToChildren(origin uint64, childRes int) (_r0 *Set, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3_cell_to_children(C.uint64_t(origin), C.int(childRes))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Set{_inner: _cret}, nil
+}
+
+
+// H3CompactCells wraps MEOS C function h3_compact_cells.
+func H3CompactCells(cells *Set) (_r0 *Set, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3_compact_cells(cells._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Set{_inner: _cret}, nil
+}
+
+
+// H3UncompactCells wraps MEOS C function h3_uncompact_cells.
+func H3UncompactCells(cells *Set, res int) (_r0 *Set, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3_uncompact_cells(cells._inner, C.int(res))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Set{_inner: _cret}, nil
+}
+
+
+// H3GridRing wraps MEOS C function h3_grid_ring.
+func H3GridRing(origin uint64, k int) (_r0 *Set, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3_grid_ring(C.uint64_t(origin), C.int(k))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Set{_inner: _cret}, nil
+}
+
+
+// H3GridPathCells wraps MEOS C function h3_grid_path_cells.
+func H3GridPathCells(start uint64, end uint64) (_r0 *Set, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3_grid_path_cells(C.uint64_t(start), C.uint64_t(end))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Set{_inner: _cret}, nil
+}
+
+
+// H3OriginToDirectedEdges wraps MEOS C function h3_origin_to_directed_edges.
+func H3OriginToDirectedEdges(origin uint64) (_r0 *Set, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3_origin_to_directed_edges(C.uint64_t(origin))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Set{_inner: _cret}, nil
+}
+
+
+// H3CellToVertexes wraps MEOS C function h3_cell_to_vertexes.
+func H3CellToVertexes(cell uint64) (_r0 *Set, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3_cell_to_vertexes(C.uint64_t(cell))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Set{_inner: _cret}, nil
+}
+
+
+// H3GetIcosahedronFaces wraps MEOS C function h3_get_icosahedron_faces.
+func H3GetIcosahedronFaces(cell uint64) (_r0 *Set, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3_get_icosahedron_faces(C.uint64_t(cell))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Set{_inner: _cret}, nil
+}
+
+
 // H3indexFromWKB wraps MEOS C function h3index_from_wkb.
 func H3indexFromWKB(wkb unsafe.Pointer, size uint) (_r0 uint64, _err error) {
 	C.meos_errno_reset()
@@ -131,6 +377,61 @@ func H3indexAsHexwkb(cell uint64, variant uint8, size_out unsafe.Pointer) (_r0 s
 }
 
 
+// H3indexGetResolution wraps MEOS C function h3index_get_resolution.
+func H3indexGetResolution(cell uint64) (_r0 uint32, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3index_get_resolution(C.uint64_t(cell))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return uint32(_cret), nil
+}
+
+
+// H3indexCellToParent wraps MEOS C function h3index_cell_to_parent.
+func H3indexCellToParent(cell uint64, parent_resolution uint32) (_r0 uint64, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3index_cell_to_parent(C.uint64_t(cell), C.uint32_t(parent_resolution))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return uint64(_cret), nil
+}
+
+
+// H3indexCellToPoint wraps MEOS C function h3index_cell_to_point.
+func H3indexCellToPoint(cell uint64) (_r0 *Geom, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3index_cell_to_point(C.uint64_t(cell))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Geom{_inner: _cret}, nil
+}
+
+
+// H3indexCellToBoundary wraps MEOS C function h3index_cell_to_boundary.
+func H3indexCellToBoundary(cell uint64) (_r0 *Geom, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3index_cell_to_boundary(C.uint64_t(cell))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Geom{_inner: _cret}, nil
+}
+
+
+// H3indexCellArea wraps MEOS C function h3index_cell_area.
+func H3indexCellArea(cell uint64) (_r0 float64, _err error) {
+	C.meos_errno_reset()
+	_cret := C.h3index_cell_area(C.uint64_t(cell))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return float64(_cret), nil
+}
+
+
 // Th3indexIn wraps MEOS C function th3index_in.
 func Th3indexIn(str string) (_r0 *Temporal, _err error) {
 	_c_str := C.CString(str)
@@ -504,17 +805,6 @@ func TneTh3indexTh3index(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err
 }
 
 
-// Th3indexGetResolution wraps MEOS C function th3index_get_resolution.
-func Th3indexGetResolution(temp *Temporal) (_r0 *Temporal, _err error) {
-	C.meos_errno_reset()
-	_cret := C.th3index_get_resolution(temp._inner)
-	if _err = meosError(); _err != nil {
-		return
-	}
-	return &Temporal{_inner: _cret}, nil
-}
-
-
 // Th3indexGetBaseCellNumber wraps MEOS C function th3index_get_base_cell_number.
 func Th3indexGetBaseCellNumber(temp *Temporal) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -526,17 +816,6 @@ func Th3indexGetBaseCellNumber(temp *Temporal) (_r0 *Temporal, _err error) {
 }
 
 
-// Th3indexIsValidCell wraps MEOS C function th3index_is_valid_cell.
-func Th3indexIsValidCell(temp *Temporal) (_r0 *Temporal, _err error) {
-	C.meos_errno_reset()
-	_cret := C.th3index_is_valid_cell(temp._inner)
-	if _err = meosError(); _err != nil {
-		return
-	}
-	return &Temporal{_inner: _cret}, nil
-}
-
-
 // Th3indexIsResClassIii wraps MEOS C function th3index_is_res_class_iii.
 func Th3indexIsResClassIii(temp *Temporal) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -559,17 +838,6 @@ func Th3indexIsPentagon(temp *Temporal) (_r0 *Temporal, _err error) {
 }
 
 
-// Th3indexCellToParent wraps MEOS C function th3index_cell_to_parent.
-func Th3indexCellToParent(temp *Temporal, resolution int32) (_r0 *Temporal, _err error) {
-	C.meos_errno_reset()
-	_cret := C.th3index_cell_to_parent(temp._inner, C.int32(resolution))
-	if _err = meosError(); _err != nil {
-		return
-	}
-	return &Temporal{_inner: _cret}, nil
-}
-
-
 // Th3indexCellToParentNext wraps MEOS C function th3index_cell_to_parent_next.
 func Th3indexCellToParentNext(temp *Temporal) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -669,14 +937,14 @@ func Th3indexToTgeompoint(temp *Temporal) (_r0 *Temporal, _err error) {
 }
 
 
-// Th3indexCellToBoundary wraps MEOS C function th3index_cell_to_boundary.
-func Th3indexCellToBoundary(temp *Temporal) (_r0 *Temporal, _err error) {
+// H3indexToSet wraps MEOS C function h3index_to_set.
+func H3indexToSet(cell uint64) (_r0 *Set, _err error) {
 	C.meos_errno_reset()
-	_cret := C.th3index_cell_to_boundary(temp._inner)
+	_cret := C.h3index_to_set(C.uint64_t(cell))
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return &Temporal{_inner: _cret}, nil
+	return &Set{_inner: _cret}, nil
 }
 
 
@@ -878,25 +1146,10 @@ func Th3indexLocalIjToCell(origin *Temporal, coord *Temporal) (_r0 *Temporal, _e
 }
 
 
-// Th3indexCellArea wraps MEOS C function th3index_cell_area.
-func Th3indexCellArea(temp *Temporal, unit string) (_r0 *Temporal, _err error) {
-	_c_unit := C.CString(unit)
-	defer C.free(unsafe.Pointer(_c_unit))
-	C.meos_errno_reset()
-	_cret := C.th3index_cell_area(temp._inner, _c_unit)
-	if _err = meosError(); _err != nil {
-		return
-	}
-	return &Temporal{_inner: _cret}, nil
-}
-
-
 // Th3indexEdgeLength wraps MEOS C function th3index_edge_length.
-func Th3indexEdgeLength(temp *Temporal, unit string) (_r0 *Temporal, _err error) {
-	_c_unit := C.CString(unit)
-	defer C.free(unsafe.Pointer(_c_unit))
+func Th3indexEdgeLength(temp *Temporal) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
-	_cret := C.th3index_edge_length(temp._inner, _c_unit)
+	_cret := C.th3index_edge_length(temp._inner)
 	if _err = meosError(); _err != nil {
 		return
 	}
@@ -905,11 +1158,9 @@ func Th3indexEdgeLength(temp *Temporal, unit string) (_r0 *Temporal, _err error)
 
 
 // TgeogpointGreatCircleDistance wraps MEOS C function tgeogpoint_great_circle_distance.
-func TgeogpointGreatCircleDistance(a *Temporal, b *Temporal, unit string) (_r0 *Temporal, _err error) {
-	_c_unit := C.CString(unit)
-	defer C.free(unsafe.Pointer(_c_unit))
+func TgeogpointGreatCircleDistance(a *Temporal, b *Temporal) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
-	_cret := C.tgeogpoint_great_circle_distance(a._inner, b._inner, _c_unit)
+	_cret := C.tgeogpoint_great_circle_distance(a._inner, b._inner)
 	if _err = meosError(); _err != nil {
 		return
 	}
diff --git a/functions/meos_meos_internal.go b/functions/meos_meos_internal.go
index 82015c9..358e265 100644
--- a/functions/meos_meos_internal.go
+++ b/functions/meos_meos_internal.go
@@ -36,6 +36,7 @@ package functions
 #define gunion_pcpatch_set union_pcpatch_set
 #define gunion_pcpoint_set union_pcpoint_set
 #define gunion_pose_set union_pose_set
+#define gunion_posechain_set union_posechain_set
 #define gunion_set_bigint union_set_bigint
 #define gunion_set_cbuffer union_set_cbuffer
 #define gunion_set_date union_set_date
@@ -47,6 +48,7 @@ package functions
 #define gunion_set_pcpatch union_set_pcpatch
 #define gunion_set_pcpoint union_set_pcpoint
 #define gunion_set_pose union_set_pose
+#define gunion_set_posechain union_set_posechain
 #define gunion_set_set union_set_set
 #define gunion_set_text union_set_text
 #define gunion_set_timestamptz union_set_timestamptz
@@ -85,25 +87,58 @@ import (
 
 var _ = unsafe.Pointer(nil)
 
-// GslGetGenerationRng wraps MEOS C function gsl_get_generation_rng.
-func GslGetGenerationRng() (_r0 *GslRng, _err error) {
+// PrngGetGenerationRng wraps MEOS C function prng_get_generation_rng.
+func PrngGetGenerationRng() (_r0 unsafe.Pointer, _err error) {
 	C.meos_errno_reset()
-	_cret := C.gsl_get_generation_rng()
+	_cret := C.prng_get_generation_rng()
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return &GslRng{_inner: _cret}, nil
+	return unsafe.Pointer(_cret), nil
+}
+
+
+// PrngGetAggregationRng wraps MEOS C function prng_get_aggregation_rng.
+func PrngGetAggregationRng() (_r0 unsafe.Pointer, _err error) {
+	C.meos_errno_reset()
+	_cret := C.prng_get_aggregation_rng()
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return unsafe.Pointer(_cret), nil
 }
 
 
-// GslGetAggregationRng wraps MEOS C function gsl_get_aggregation_rng.
-func GslGetAggregationRng() (_r0 *GslRng, _err error) {
+// MeosRandomDouble wraps MEOS C function meos_random_double.
+func MeosRandomDouble(rng unsafe.Pointer) (_r0 float64, _err error) {
 	C.meos_errno_reset()
-	_cret := C.gsl_get_aggregation_rng()
+	_cret := C.meos_random_double((*C.pg_prng_state)(unsafe.Pointer(rng)))
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return &GslRng{_inner: _cret}, nil
+	return float64(_cret), nil
+}
+
+
+// MeosRandomExponential wraps MEOS C function meos_random_exponential.
+func MeosRandomExponential(rng unsafe.Pointer, mean float64) (_r0 float64, _err error) {
+	C.meos_errno_reset()
+	_cret := C.meos_random_exponential((*C.pg_prng_state)(unsafe.Pointer(rng)), C.double(mean))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return float64(_cret), nil
+}
+
+
+// MeosRandomBinomial20Half wraps MEOS C function meos_random_binomial20_half.
+func MeosRandomBinomial20Half(rng unsafe.Pointer) (_r0 uint32, _err error) {
+	C.meos_errno_reset()
+	_cret := C.meos_random_binomial20_half((*C.pg_prng_state)(unsafe.Pointer(rng)))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return uint32(_cret), nil
 }
 
 
@@ -525,6 +560,21 @@ func EnsureBboxTemporalCompatible(bboxtype MeosType, temp *Temporal) (_r0 bool,
 }
 
 
+// EnsureSameIndexBboxtype wraps MEOS C function ensure_same_index_bboxtype.
+func EnsureSameIndexBboxtype(bboxtype1 MeosType, bboxtype2 MeosType) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.ensure_same_index_bboxtype(C.MeosType(bboxtype1), C.MeosType(bboxtype2))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// TODO ensure_index_join_op: unsupported param IndexSearchOp
+// func EnsureIndexJoinOp(...) { /* not yet handled by codegen */ }
+
+
 // BboxTemporalSplitBoxes wraps MEOS C function bbox_temporal_split_boxes.
 func BboxTemporalSplitBoxes(bboxtype MeosType, boxsize uint, temp *Temporal, maxboxes int, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) {
 	C.meos_errno_reset()
@@ -536,6 +586,105 @@ func BboxTemporalSplitBoxes(bboxtype MeosType, boxsize uint, temp *Temporal, max
 }
 
 
+// SpanContains wraps MEOS C function span_contains.
+func SpanContains(s1 *Span, s2 *Span) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.span_contains(s1._inner, s2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// SpanContained wraps MEOS C function span_contained.
+func SpanContained(s1 *Span, s2 *Span) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.span_contained(s1._inner, s2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// SpanOverlaps wraps MEOS C function span_overlaps.
+func SpanOverlaps(s1 *Span, s2 *Span) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.span_overlaps(s1._inner, s2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// SpanSame wraps MEOS C function span_same.
+func SpanSame(s1 *Span, s2 *Span) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.span_same(s1._inner, s2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// SpanAdjacent wraps MEOS C function span_adjacent.
+func SpanAdjacent(s1 *Span, s2 *Span) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.span_adjacent(s1._inner, s2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// SpanLeft wraps MEOS C function span_left.
+func SpanLeft(s1 *Span, s2 *Span) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.span_left(s1._inner, s2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// SpanRight wraps MEOS C function span_right.
+func SpanRight(s1 *Span, s2 *Span) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.span_right(s1._inner, s2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// SpanOverleft wraps MEOS C function span_overleft.
+func SpanOverleft(s1 *Span, s2 *Span) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.span_overleft(s1._inner, s2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// SpanOverright wraps MEOS C function span_overright.
+func SpanOverright(s1 *Span, s2 *Span) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.span_overright(s1._inner, s2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
 // BboxUnionSpanSpan wraps MEOS C function bbox_union_span_span.
 func BboxUnionSpanSpan(s1 *Span, s2 *Span) (_r0 *Span, _err error) {
 	var _out_result C.Span
@@ -671,6 +820,149 @@ func TBOXExpand(box1 *TBox, box2 *TBox) (_err error) {
 }
 
 
+// TBOXContains wraps MEOS C function tbox_contains.
+func TBOXContains(box1 *TBox, box2 *TBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tbox_contains(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// TBOXContained wraps MEOS C function tbox_contained.
+func TBOXContained(box1 *TBox, box2 *TBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tbox_contained(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// TBOXOverlaps wraps MEOS C function tbox_overlaps.
+func TBOXOverlaps(box1 *TBox, box2 *TBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tbox_overlaps(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// TBOXSame wraps MEOS C function tbox_same.
+func TBOXSame(box1 *TBox, box2 *TBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tbox_same(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// TBOXAdjacent wraps MEOS C function tbox_adjacent.
+func TBOXAdjacent(box1 *TBox, box2 *TBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tbox_adjacent(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// TBOXLeft wraps MEOS C function tbox_left.
+func TBOXLeft(box1 *TBox, box2 *TBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tbox_left(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// TBOXRight wraps MEOS C function tbox_right.
+func TBOXRight(box1 *TBox, box2 *TBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tbox_right(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// TBOXOverleft wraps MEOS C function tbox_overleft.
+func TBOXOverleft(box1 *TBox, box2 *TBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tbox_overleft(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// TBOXOverright wraps MEOS C function tbox_overright.
+func TBOXOverright(box1 *TBox, box2 *TBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tbox_overright(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// TBOXBefore wraps MEOS C function tbox_before.
+func TBOXBefore(box1 *TBox, box2 *TBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tbox_before(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// TBOXAfter wraps MEOS C function tbox_after.
+func TBOXAfter(box1 *TBox, box2 *TBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tbox_after(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// TBOXOverbefore wraps MEOS C function tbox_overbefore.
+func TBOXOverbefore(box1 *TBox, box2 *TBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tbox_overbefore(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// TBOXOverafter wraps MEOS C function tbox_overafter.
+func TBOXOverafter(box1 *TBox, box2 *TBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tbox_overafter(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
 // InterTBOXTBOX wraps MEOS C function inter_tbox_tbox.
 func InterTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 bool, _r1 *TBox, _err error) {
 	var _out_result C.TBox
diff --git a/functions/meos_meos_internal_geo.go b/functions/meos_meos_internal_geo.go
index 0f84396..698d190 100644
--- a/functions/meos_meos_internal_geo.go
+++ b/functions/meos_meos_internal_geo.go
@@ -36,6 +36,7 @@ package functions
 #define gunion_pcpatch_set union_pcpatch_set
 #define gunion_pcpoint_set union_pcpoint_set
 #define gunion_pose_set union_pose_set
+#define gunion_posechain_set union_posechain_set
 #define gunion_set_bigint union_set_bigint
 #define gunion_set_cbuffer union_set_cbuffer
 #define gunion_set_date union_set_date
@@ -47,6 +48,7 @@ package functions
 #define gunion_set_pcpatch union_set_pcpatch
 #define gunion_set_pcpoint union_set_pcpoint
 #define gunion_set_pose union_set_pose
+#define gunion_set_posechain union_set_posechain
 #define gunion_set_set union_set_set
 #define gunion_set_text union_set_text
 #define gunion_set_timestamptz union_set_timestamptz
@@ -85,10 +87,10 @@ import (
 
 var _ = unsafe.Pointer(nil)
 
-// ProjGetContext wraps MEOS C function proj_get_context.
-func ProjGetContext() (_r0 *PJContext, _err error) {
+// MeosProjGetContext wraps MEOS C function meos_proj_get_context.
+func MeosProjGetContext() (_r0 *PJContext, _err error) {
 	C.meos_errno_reset()
-	_cret := C.proj_get_context()
+	_cret := C.meos_proj_get_context()
 	if _err = meosError(); _err != nil {
 		return
 	}
@@ -261,6 +263,237 @@ func STBOXExpandSpaceSet(box *STBox, d float64) (_r0 bool, _r1 *STBox, _err erro
 }
 
 
+// STBOXContains wraps MEOS C function stbox_contains.
+func STBOXContains(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_contains(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXContained wraps MEOS C function stbox_contained.
+func STBOXContained(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_contained(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXOverlaps wraps MEOS C function stbox_overlaps.
+func STBOXOverlaps(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_overlaps(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXSame wraps MEOS C function stbox_same.
+func STBOXSame(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_same(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXAdjacent wraps MEOS C function stbox_adjacent.
+func STBOXAdjacent(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_adjacent(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXLeft wraps MEOS C function stbox_left.
+func STBOXLeft(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_left(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXRight wraps MEOS C function stbox_right.
+func STBOXRight(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_right(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXOverleft wraps MEOS C function stbox_overleft.
+func STBOXOverleft(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_overleft(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXOverright wraps MEOS C function stbox_overright.
+func STBOXOverright(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_overright(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXBelow wraps MEOS C function stbox_below.
+func STBOXBelow(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_below(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXAbove wraps MEOS C function stbox_above.
+func STBOXAbove(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_above(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXOverbelow wraps MEOS C function stbox_overbelow.
+func STBOXOverbelow(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_overbelow(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXOverabove wraps MEOS C function stbox_overabove.
+func STBOXOverabove(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_overabove(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXFront wraps MEOS C function stbox_front.
+func STBOXFront(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_front(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXBack wraps MEOS C function stbox_back.
+func STBOXBack(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_back(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXOverfront wraps MEOS C function stbox_overfront.
+func STBOXOverfront(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_overfront(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXOverback wraps MEOS C function stbox_overback.
+func STBOXOverback(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_overback(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXBefore wraps MEOS C function stbox_before.
+func STBOXBefore(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_before(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXAfter wraps MEOS C function stbox_after.
+func STBOXAfter(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_after(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXOverbefore wraps MEOS C function stbox_overbefore.
+func STBOXOverbefore(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_overbefore(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// STBOXOverafter wraps MEOS C function stbox_overafter.
+func STBOXOverafter(box1 *STBox, box2 *STBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_overafter(box1._inner, box2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
 // InterSTBOXSTBOX wraps MEOS C function inter_stbox_stbox.
 func InterSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _r1 *STBox, _err error) {
 	var _out_result C.STBox
@@ -273,6 +506,17 @@ func InterSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _r1 *STBox, _err error
 }
 
 
+// STBOXGeo wraps MEOS C function stbox_geo.
+func STBOXGeo(box *STBox) (_r0 *Geom, _err error) {
+	C.meos_errno_reset()
+	_cret := C.stbox_geo(box._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Geom{_inner: _cret}, nil
+}
+
+
 // TgeogpointinstIn wraps MEOS C function tgeogpointinst_in.
 func TgeogpointinstIn(str string) (_r0 *TInstant, _err error) {
 	_c_str := C.CString(str)
@@ -441,6 +685,17 @@ func TspatialSetSTBOX(temp *Temporal) (_r0 *STBox, _err error) {
 }
 
 
+// TgeoinstSetSTBOX wraps MEOS C function tgeoinst_set_stbox.
+func TgeoinstSetSTBOX(inst *TInstant, box *STBox) (_err error) {
+	C.meos_errno_reset()
+	C.tgeoinst_set_stbox(inst._inner, box._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return nil
+}
+
+
 // TspatialseqSetSTBOX wraps MEOS C function tspatialseq_set_stbox.
 func TspatialseqSetSTBOX(seq *TSequence, box *STBox) (_err error) {
 	C.meos_errno_reset()
@@ -562,10 +817,10 @@ func TgeoseqsetRestrictSTBOX(ss *TSequenceSet, box *STBox, border_inc bool, atfu
 }
 
 
-// GeoClipCtxMake wraps MEOS C function geo_clip_ctx_make.
-func GeoClipCtxMake(gs *Geom) (_r0 unsafe.Pointer, _err error) {
+// GeoEdgeCtxMake wraps MEOS C function geo_edge_ctx_make.
+func GeoEdgeCtxMake(gs *Geom) (_r0 unsafe.Pointer, _err error) {
 	C.meos_errno_reset()
-	_cret := C.geo_clip_ctx_make(gs._inner)
+	_cret := C.geo_edge_ctx_make(gs._inner)
 	if _err = meosError(); _err != nil {
 		return
 	}
@@ -573,10 +828,10 @@ func GeoClipCtxMake(gs *Geom) (_r0 unsafe.Pointer, _err error) {
 }
 
 
-// GeoClipCtxFree wraps MEOS C function geo_clip_ctx_free.
-func GeoClipCtxFree(ctx unsafe.Pointer) (_err error) {
+// GeoEdgeCtxFree wraps MEOS C function geo_edge_ctx_free.
+func GeoEdgeCtxFree(ctx unsafe.Pointer) (_err error) {
 	C.meos_errno_reset()
-	C.geo_clip_ctx_free(unsafe.Pointer(ctx))
+	C.geo_edge_ctx_free(unsafe.Pointer(ctx))
 	if _err = meosError(); _err != nil {
 		return
 	}
@@ -683,10 +938,10 @@ func TpointLinearRestrictGeom(temp *Temporal, gs *Geom, atfunc bool) (_r0 *Tempo
 }
 
 
-// GeomClipSupported wraps MEOS C function geom_clip_supported.
-func GeomClipSupported(geom unsafe.Pointer) (_r0 bool, _err error) {
+// GeomMeosSupported wraps MEOS C function geom_meos_supported.
+func GeomMeosSupported(geom unsafe.Pointer) (_r0 bool, _err error) {
 	C.meos_errno_reset()
-	_cret := C.geom_clip_supported((*C.LWGEOM)(unsafe.Pointer(geom)))
+	_cret := C.geom_meos_supported((*C.LWGEOM)(unsafe.Pointer(geom)))
 	if _err = meosError(); _err != nil {
 		return
 	}
@@ -848,6 +1103,17 @@ func TgeoseqsetSplitNStboxes(ss *TSequenceSet, max_count int, count unsafe.Point
 }
 
 
+// TpointGetCoord wraps MEOS C function tpoint_get_coord.
+func TpointGetCoord(temp *Temporal, coord int) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tpoint_get_coord(temp._inner, C.int(coord))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TgeominstTgeoginst wraps MEOS C function tgeominst_tgeoginst.
 func TgeominstTgeoginst(inst *TInstant, oper bool) (_r0 *TInstant, _err error) {
 	C.meos_errno_reset()
diff --git a/functions/meos_meos_json.go b/functions/meos_meos_json.go
index c783e54..3cb4a9d 100644
--- a/functions/meos_meos_json.go
+++ b/functions/meos_meos_json.go
@@ -36,6 +36,7 @@ package functions
 #define gunion_pcpatch_set union_pcpatch_set
 #define gunion_pcpoint_set union_pcpoint_set
 #define gunion_pose_set union_pose_set
+#define gunion_posechain_set union_posechain_set
 #define gunion_set_bigint union_set_bigint
 #define gunion_set_cbuffer union_set_cbuffer
 #define gunion_set_date union_set_date
@@ -47,6 +48,7 @@ package functions
 #define gunion_set_pcpatch union_set_pcpatch
 #define gunion_set_pcpoint union_set_pcpoint
 #define gunion_set_pose union_set_pose
+#define gunion_set_posechain union_set_posechain
 #define gunion_set_set union_set_set
 #define gunion_set_text union_set_text
 #define gunion_set_timestamptz union_set_timestamptz
diff --git a/functions/meos_meos_npoint.go b/functions/meos_meos_npoint.go
index d541c61..63108e8 100644
--- a/functions/meos_meos_npoint.go
+++ b/functions/meos_meos_npoint.go
@@ -36,6 +36,7 @@ package functions
 #define gunion_pcpatch_set union_pcpatch_set
 #define gunion_pcpoint_set union_pcpoint_set
 #define gunion_pose_set union_pose_set
+#define gunion_posechain_set union_posechain_set
 #define gunion_set_bigint union_set_bigint
 #define gunion_set_cbuffer union_set_cbuffer
 #define gunion_set_date union_set_date
@@ -47,6 +48,7 @@ package functions
 #define gunion_set_pcpatch union_set_pcpatch
 #define gunion_set_pcpoint union_set_pcpoint
 #define gunion_set_pose union_set_pose
+#define gunion_set_posechain union_set_posechain
 #define gunion_set_set union_set_set
 #define gunion_set_text union_set_text
 #define gunion_set_timestamptz union_set_timestamptz
diff --git a/functions/meos_meos_pointcloud.go b/functions/meos_meos_pointcloud.go
index 0f97570..25bb119 100644
--- a/functions/meos_meos_pointcloud.go
+++ b/functions/meos_meos_pointcloud.go
@@ -36,6 +36,7 @@ package functions
 #define gunion_pcpatch_set union_pcpatch_set
 #define gunion_pcpoint_set union_pcpoint_set
 #define gunion_pose_set union_pose_set
+#define gunion_posechain_set union_posechain_set
 #define gunion_set_bigint union_set_bigint
 #define gunion_set_cbuffer union_set_cbuffer
 #define gunion_set_date union_set_date
@@ -47,6 +48,7 @@ package functions
 #define gunion_set_pcpatch union_set_pcpatch
 #define gunion_set_pcpoint union_set_pcpoint
 #define gunion_set_pose union_set_pose
+#define gunion_set_posechain union_set_posechain
 #define gunion_set_set union_set_set
 #define gunion_set_text union_set_text
 #define gunion_set_timestamptz union_set_timestamptz
@@ -133,6 +135,17 @@ func PcpointAsHexwkb(pt *Pcpoint) (_r0 string, _err error) {
 }
 
 
+// PcpointMake wraps MEOS C function pcpoint_make.
+func PcpointMake(pcid uint32, values unsafe.Pointer, count int) (_r0 *Pcpoint, _err error) {
+	C.meos_errno_reset()
+	_cret := C.pcpoint_make(C.uint32_t(pcid), (*C.double)(unsafe.Pointer(values)), C.int(count))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Pcpoint{_inner: _cret}, nil
+}
+
+
 // PcpointCopy wraps MEOS C function pcpoint_copy.
 func PcpointCopy(pt *Pcpoint) (_r0 *Pcpoint, _err error) {
 	C.meos_errno_reset()
@@ -256,6 +269,32 @@ func MeosPcSchemaRegister(pcid uint32, schema *PCSchema) (_err error) {
 }
 
 
+// MeosPcSchemaFromDims wraps MEOS C function meos_pc_schema_from_dims.
+func MeosPcSchemaFromDims(pcid uint32, srid int32, compression string, dims unsafe.Pointer, ndims int) (_r0 *PCSchema, _err error) {
+	_c_compression := C.CString(compression)
+	defer C.free(unsafe.Pointer(_c_compression))
+	C.meos_errno_reset()
+	_cret := C.meos_pc_schema_from_dims(C.uint32_t(pcid), C.int32_t(srid), _c_compression, (*C.PCDimensionSpec)(unsafe.Pointer(dims)), C.int(ndims))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &PCSchema{_inner: _cret}, nil
+}
+
+
+// MeosPcSchemaRegisterDims wraps MEOS C function meos_pc_schema_register_dims.
+func MeosPcSchemaRegisterDims(pcid uint32, srid int32, compression string, dims unsafe.Pointer, ndims int) (_r0 bool, _err error) {
+	_c_compression := C.CString(compression)
+	defer C.free(unsafe.Pointer(_c_compression))
+	C.meos_errno_reset()
+	_cret := C.meos_pc_schema_register_dims(C.uint32_t(pcid), C.int32_t(srid), _c_compression, (*C.PCDimensionSpec)(unsafe.Pointer(dims)), C.int(ndims))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
 // MeosPcSchemaRegisterXml wraps MEOS C function meos_pc_schema_register_xml.
 func MeosPcSchemaRegisterXml(pcid uint32, schema *PCSchema, xml_text string) (_err error) {
 	_c_xml_text := C.CString(xml_text)
@@ -291,6 +330,52 @@ func MeosPcSchemaClear() (_err error) {
 }
 
 
+// MeosPcSchemaSRID wraps MEOS C function meos_pc_schema_srid.
+func MeosPcSchemaSRID(pcid uint32) (_r0 int32, _err error) {
+	C.meos_errno_reset()
+	_cret := C.meos_pc_schema_srid(C.uint32_t(pcid))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return int32(_cret), nil
+}
+
+
+// MeosPcSchemaCompression wraps MEOS C function meos_pc_schema_compression.
+func MeosPcSchemaCompression(pcid uint32) (_r0 string, _err error) {
+	C.meos_errno_reset()
+	_cret := C.meos_pc_schema_compression(C.uint32_t(pcid))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(_cret), nil
+}
+
+
+// MeosPcSchemaNdims wraps MEOS C function meos_pc_schema_ndims.
+func MeosPcSchemaNdims(pcid uint32) (_r0 int32, _err error) {
+	C.meos_errno_reset()
+	_cret := C.meos_pc_schema_ndims(C.uint32_t(pcid))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return int32(_cret), nil
+}
+
+
+// MeosSetPointcloudSchemasXml wraps MEOS C function meos_set_pointcloud_schemas_xml.
+func MeosSetPointcloudSchemasXml(path string) (_err error) {
+	_c_path := C.CString(path)
+	defer C.free(unsafe.Pointer(_c_path))
+	C.meos_errno_reset()
+	C.meos_set_pointcloud_schemas_xml(_c_path)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return nil
+}
+
+
 // PcpointCmp wraps MEOS C function pcpoint_cmp.
 func PcpointCmp(pt1 *Pcpoint, pt2 *Pcpoint) (_r0 int, _err error) {
 	C.meos_errno_reset()
@@ -416,6 +501,28 @@ func PcpatchAsHexwkb(pa *Pcpatch) (_r0 string, _err error) {
 }
 
 
+// PcpatchMake wraps MEOS C function pcpatch_make.
+func PcpatchMake(points unsafe.Pointer, count int) (_r0 *Pcpatch, _err error) {
+	C.meos_errno_reset()
+	_cret := C.pcpatch_make((**C.Pcpoint)(unsafe.Pointer(points)), C.int(count))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Pcpatch{_inner: _cret}, nil
+}
+
+
+// PcpatchMakeCoords wraps MEOS C function pcpatch_make_coords.
+func PcpatchMakeCoords(pcid uint32, values unsafe.Pointer, count int) (_r0 *Pcpatch, _err error) {
+	C.meos_errno_reset()
+	_cret := C.pcpatch_make_coords(C.uint32_t(pcid), (*C.double)(unsafe.Pointer(values)), C.int(count))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Pcpatch{_inner: _cret}, nil
+}
+
+
 // PcpatchCopy wraps MEOS C function pcpatch_copy.
 func PcpatchCopy(pa *Pcpatch) (_r0 *Pcpatch, _err error) {
 	C.meos_errno_reset()
@@ -471,6 +578,17 @@ func PcpatchHashExtended(pa *Pcpatch, seed uint64) (_r0 uint64, _err error) {
 }
 
 
+// PcpatchToGeom wraps MEOS C function pcpatch_to_geom.
+func PcpatchToGeom(pa *Pcpatch) (_r0 *Geom, _err error) {
+	C.meos_errno_reset()
+	_cret := C.pcpatch_to_geom(pa._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Geom{_inner: _cret}, nil
+}
+
+
 // PcpatchCmp wraps MEOS C function pcpatch_cmp.
 func PcpatchCmp(pa1 *Pcpatch, pa2 *Pcpatch) (_r0 int, _err error) {
 	C.meos_errno_reset()
@@ -1568,6 +1686,17 @@ func TpointcloudToTgeompoint(temp *Temporal) (_r0 *Temporal, _err error) {
 }
 
 
+// TpcpatchToTgeometry wraps MEOS C function tpcpatch_to_tgeometry.
+func TpcpatchToTgeometry(temp *Temporal) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tpcpatch_to_tgeometry(temp._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TpcpointinstMake wraps MEOS C function tpcpointinst_make.
 func TpcpointinstMake(pt *Pcpoint, t int64) (_r0 *TInstant, _err error) {
 	C.meos_errno_reset()
@@ -2188,6 +2317,171 @@ func TneTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) (_r0 *Temporal, _err error)
 }
 
 
+// AdjacentTpcboxTpointcloud wraps MEOS C function adjacent_tpcbox_tpointcloud.
+func AdjacentTpcboxTpointcloud(box *TPCBox, temp *Temporal) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.adjacent_tpcbox_tpointcloud(box._inner, temp._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// AdjacentTpointcloudTpcbox wraps MEOS C function adjacent_tpointcloud_tpcbox.
+func AdjacentTpointcloudTpcbox(temp *Temporal, box *TPCBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.adjacent_tpointcloud_tpcbox(temp._inner, box._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// AdjacentTpointcloudTpointcloud wraps MEOS C function adjacent_tpointcloud_tpointcloud.
+func AdjacentTpointcloudTpointcloud(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.adjacent_tpointcloud_tpointcloud(temp1._inner, temp2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// ContainedTpcboxTpointcloud wraps MEOS C function contained_tpcbox_tpointcloud.
+func ContainedTpcboxTpointcloud(box *TPCBox, temp *Temporal) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.contained_tpcbox_tpointcloud(box._inner, temp._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// ContainedTpointcloudTpcbox wraps MEOS C function contained_tpointcloud_tpcbox.
+func ContainedTpointcloudTpcbox(temp *Temporal, box *TPCBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.contained_tpointcloud_tpcbox(temp._inner, box._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// ContainedTpointcloudTpointcloud wraps MEOS C function contained_tpointcloud_tpointcloud.
+func ContainedTpointcloudTpointcloud(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.contained_tpointcloud_tpointcloud(temp1._inner, temp2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// ContainsTpcboxTpointcloud wraps MEOS C function contains_tpcbox_tpointcloud.
+func ContainsTpcboxTpointcloud(box *TPCBox, temp *Temporal) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.contains_tpcbox_tpointcloud(box._inner, temp._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// ContainsTpointcloudTpcbox wraps MEOS C function contains_tpointcloud_tpcbox.
+func ContainsTpointcloudTpcbox(temp *Temporal, box *TPCBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.contains_tpointcloud_tpcbox(temp._inner, box._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// ContainsTpointcloudTpointcloud wraps MEOS C function contains_tpointcloud_tpointcloud.
+func ContainsTpointcloudTpointcloud(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.contains_tpointcloud_tpointcloud(temp1._inner, temp2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// OverlapsTpcboxTpointcloud wraps MEOS C function overlaps_tpcbox_tpointcloud.
+func OverlapsTpcboxTpointcloud(box *TPCBox, temp *Temporal) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.overlaps_tpcbox_tpointcloud(box._inner, temp._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// OverlapsTpointcloudTpcbox wraps MEOS C function overlaps_tpointcloud_tpcbox.
+func OverlapsTpointcloudTpcbox(temp *Temporal, box *TPCBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.overlaps_tpointcloud_tpcbox(temp._inner, box._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// OverlapsTpointcloudTpointcloud wraps MEOS C function overlaps_tpointcloud_tpointcloud.
+func OverlapsTpointcloudTpointcloud(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.overlaps_tpointcloud_tpointcloud(temp1._inner, temp2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// SameTpcboxTpointcloud wraps MEOS C function same_tpcbox_tpointcloud.
+func SameTpcboxTpointcloud(box *TPCBox, temp *Temporal) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.same_tpcbox_tpointcloud(box._inner, temp._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// SameTpointcloudTpcbox wraps MEOS C function same_tpointcloud_tpcbox.
+func SameTpointcloudTpcbox(temp *Temporal, box *TPCBox) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.same_tpointcloud_tpcbox(temp._inner, box._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
+// SameTpointcloudTpointcloud wraps MEOS C function same_tpointcloud_tpointcloud.
+func SameTpointcloudTpointcloud(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) {
+	C.meos_errno_reset()
+	_cret := C.same_tpointcloud_tpointcloud(temp1._inner, temp2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return bool(_cret), nil
+}
+
+
 // EintersectsTpcpointGeo wraps MEOS C function eintersects_tpcpoint_geo.
 func EintersectsTpcpointGeo(temp *Temporal, gs *Geom) (_r0 bool, _err error) {
 	C.meos_errno_reset()
diff --git a/functions/meos_meos_pose.go b/functions/meos_meos_pose.go
index 13a65c2..0c05c61 100644
--- a/functions/meos_meos_pose.go
+++ b/functions/meos_meos_pose.go
@@ -36,6 +36,7 @@ package functions
 #define gunion_pcpatch_set union_pcpatch_set
 #define gunion_pcpoint_set union_pcpoint_set
 #define gunion_pose_set union_pose_set
+#define gunion_posechain_set union_posechain_set
 #define gunion_set_bigint union_set_bigint
 #define gunion_set_cbuffer union_set_cbuffer
 #define gunion_set_date union_set_date
@@ -47,6 +48,7 @@ package functions
 #define gunion_set_pcpatch union_set_pcpatch
 #define gunion_set_pcpoint union_set_pcpoint
 #define gunion_set_pose union_set_pose
+#define gunion_set_posechain union_set_posechain
 #define gunion_set_set union_set_set
 #define gunion_set_text union_set_text
 #define gunion_set_timestamptz union_set_timestamptz
@@ -247,6 +249,39 @@ func TposeAsGeoposeStreamElement(temp *Temporal, inst *TInstant, precision int)
 }
 
 
+// TposeAsGeoposeStream wraps MEOS C function tpose_as_geopose_stream.
+func TposeAsGeoposeStream(temp *Temporal, precision int) (_r0 string, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tpose_as_geopose_stream(temp._inner, C.int(precision))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return C.GoString(_cret), nil
+}
+
+
+// GeoposeFrames wraps MEOS C function geopose_frames.
+func GeoposeFrames(count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) {
+	C.meos_errno_reset()
+	_cret := C.geopose_frames((*C.int)(unsafe.Pointer(count)))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return unsafe.Pointer(_cret), nil
+}
+
+
+// GeoposeFrame wraps MEOS C function geopose_frame.
+func GeoposeFrame(frame_id int32) (_r0 unsafe.Pointer, _err error) {
+	C.meos_errno_reset()
+	_cret := C.geopose_frame(C.int32_t(frame_id))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return unsafe.Pointer(_cret), nil
+}
+
+
 // PoseApplyGeo wraps MEOS C function pose_apply_geo.
 func PoseApplyGeo(pose *Pose, body *Geom) (_r0 *Geom, _err error) {
 	C.meos_errno_reset()
@@ -269,6 +304,50 @@ func TposeApplyGeo(temp *Temporal, body *Geom) (_r0 *Temporal, _err error) {
 }
 
 
+// TposeComposePose wraps MEOS C function tpose_compose_pose.
+func TposeComposePose(body *Temporal, frame *Pose) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tpose_compose_pose(body._inner, frame._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
+// PoseComposeTpose wraps MEOS C function pose_compose_tpose.
+func PoseComposeTpose(body *Pose, frame *Temporal) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.pose_compose_tpose(body._inner, frame._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
+// TposeComposeTpose wraps MEOS C function tpose_compose_tpose.
+func TposeComposeTpose(body *Temporal, frame *Temporal) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tpose_compose_tpose(body._inner, frame._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
+// TposeInverse wraps MEOS C function tpose_inverse.
+func TposeInverse(temp *Temporal) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tpose_inverse(temp._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // PoseCopy wraps MEOS C function pose_copy.
 func PoseCopy(pose *Pose) (_r0 *Pose, _err error) {
 	C.meos_errno_reset()
@@ -324,6 +403,17 @@ func PoseMakePoint3d(gs *Geom, W float64, X float64, Y float64, Z float64) (_r0
 }
 
 
+// PoseMakePoint3dYpr wraps MEOS C function pose_make_point3d_ypr.
+func PoseMakePoint3dYpr(gs *Geom, yaw float64, pitch float64, roll float64) (_r0 *Pose, _err error) {
+	C.meos_errno_reset()
+	_cret := C.pose_make_point3d_ypr(gs._inner, C.double(yaw), C.double(pitch), C.double(roll))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Pose{_inner: _cret}, nil
+}
+
+
 // PoseToPoint wraps MEOS C function pose_to_point.
 func PoseToPoint(pose *Pose) (_r0 *Geom, _err error) {
 	C.meos_errno_reset()
@@ -368,10 +458,10 @@ func PoseHashExtended(pose *Pose, seed uint64) (_r0 uint64, _err error) {
 }
 
 
-// PoseOrientation wraps MEOS C function pose_orientation.
-func PoseOrientation(pose *Pose, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) {
+// PoseQuaternion wraps MEOS C function pose_quaternion.
+func PoseQuaternion(pose *Pose, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) {
 	C.meos_errno_reset()
-	_cret := C.pose_orientation(pose._inner, (*C.int)(unsafe.Pointer(count)))
+	_cret := C.pose_quaternion(pose._inner, (*C.int)(unsafe.Pointer(count)))
 	if _err = meosError(); _err != nil {
 		return
 	}
@@ -379,14 +469,14 @@ func PoseOrientation(pose *Pose, count unsafe.Pointer) (_r0 unsafe.Pointer, _err
 }
 
 
-// PoseRotation wraps MEOS C function pose_rotation.
-func PoseRotation(pose *Pose) (_r0 float64, _err error) {
+// PoseYpr wraps MEOS C function pose_ypr.
+func PoseYpr(pose *Pose, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) {
 	C.meos_errno_reset()
-	_cret := C.pose_rotation(pose._inner)
+	_cret := C.pose_ypr(pose._inner, (*C.int)(unsafe.Pointer(count)))
 	if _err = meosError(); _err != nil {
 		return
 	}
-	return float64(_cret), nil
+	return unsafe.Pointer(_cret), nil
 }
 
 
@@ -434,6 +524,28 @@ func PoseAngularDistance(pose1 *Pose, pose2 *Pose) (_r0 float64, _err error) {
 }
 
 
+// PoseCompose wraps MEOS C function pose_compose.
+func PoseCompose(body *Pose, frame *Pose) (_r0 *Pose, _err error) {
+	C.meos_errno_reset()
+	_cret := C.pose_compose(body._inner, frame._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Pose{_inner: _cret}, nil
+}
+
+
+// PoseInverse wraps MEOS C function pose_inverse.
+func PoseInverse(pose *Pose) (_r0 *Pose, _err error) {
+	C.meos_errno_reset()
+	_cret := C.pose_inverse(pose._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Pose{_inner: _cret}, nil
+}
+
+
 // PoseNormalize wraps MEOS C function pose_normalize.
 func PoseNormalize(pose *Pose) (_r0 *Pose, _err error) {
 	C.meos_errno_reset()
@@ -982,17 +1094,6 @@ func TposePoints(temp *Temporal) (_r0 *Set, _err error) {
 }
 
 
-// TposeRotation wraps MEOS C function tpose_rotation.
-func TposeRotation(temp *Temporal) (_r0 *Temporal, _err error) {
-	C.meos_errno_reset()
-	_cret := C.tpose_rotation(temp._inner)
-	if _err = meosError(); _err != nil {
-		return
-	}
-	return &Temporal{_inner: _cret}, nil
-}
-
-
 // TposeYaw wraps MEOS C function tpose_yaw.
 func TposeYaw(temp *Temporal) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -1105,6 +1206,17 @@ func TposeValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err
 }
 
 
+// TposeAtElevation wraps MEOS C function tpose_at_elevation.
+func TposeAtElevation(temp *Temporal, s *Span) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tpose_at_elevation(temp._inner, s._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TposeAtGeom wraps MEOS C function tpose_at_geom.
 func TposeAtGeom(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -1138,6 +1250,17 @@ func TposeAtPose(temp *Temporal, pose *Pose) (_r0 *Temporal, _err error) {
 }
 
 
+// TposeMinusElevation wraps MEOS C function tpose_minus_elevation.
+func TposeMinusElevation(temp *Temporal, s *Span) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.tpose_minus_elevation(temp._inner, s._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TposeMinusGeom wraps MEOS C function tpose_minus_geom.
 func TposeMinusGeom(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
diff --git a/functions/meos_meos_quadbin.go b/functions/meos_meos_quadbin.go
index 662bed6..1a694d7 100644
--- a/functions/meos_meos_quadbin.go
+++ b/functions/meos_meos_quadbin.go
@@ -36,6 +36,7 @@ package functions
 #define gunion_pcpatch_set union_pcpatch_set
 #define gunion_pcpoint_set union_pcpoint_set
 #define gunion_pose_set union_pose_set
+#define gunion_posechain_set union_posechain_set
 #define gunion_set_bigint union_set_bigint
 #define gunion_set_cbuffer union_set_cbuffer
 #define gunion_set_date union_set_date
@@ -47,6 +48,7 @@ package functions
 #define gunion_set_pcpatch union_set_pcpatch
 #define gunion_set_pcpoint union_set_pcpoint
 #define gunion_set_pose union_set_pose
+#define gunion_set_posechain union_set_posechain
 #define gunion_set_set union_set_set
 #define gunion_set_text union_set_text
 #define gunion_set_timestamptz union_set_timestamptz
@@ -596,6 +598,17 @@ func TquadbinValueAtTimestamptz(temp *Temporal, t int64, strict bool) (_r0 bool,
 }
 
 
+// QuadbinToSet wraps MEOS C function quadbin_to_set.
+func QuadbinToSet(cell uint64) (_r0 *Set, _err error) {
+	C.meos_errno_reset()
+	_cret := C.quadbin_to_set(C.uint64_t(cell))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Set{_inner: _cret}, nil
+}
+
+
 // TbigintToTquadbin wraps MEOS C function tbigint_to_tquadbin.
 func TbigintToTquadbin(temp *Temporal) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
diff --git a/functions/meos_meos_rgeo.go b/functions/meos_meos_rgeo.go
index ee9a168..f2b2b87 100644
--- a/functions/meos_meos_rgeo.go
+++ b/functions/meos_meos_rgeo.go
@@ -36,6 +36,7 @@ package functions
 #define gunion_pcpatch_set union_pcpatch_set
 #define gunion_pcpoint_set union_pcpoint_set
 #define gunion_pose_set union_pose_set
+#define gunion_posechain_set union_posechain_set
 #define gunion_set_bigint union_set_bigint
 #define gunion_set_cbuffer union_set_cbuffer
 #define gunion_set_date union_set_date
@@ -47,6 +48,7 @@ package functions
 #define gunion_set_pcpatch union_set_pcpatch
 #define gunion_set_pcpoint union_set_pcpoint
 #define gunion_set_pose union_set_pose
+#define gunion_set_posechain union_set_posechain
 #define gunion_set_set union_set_set
 #define gunion_set_text union_set_text
 #define gunion_set_timestamptz union_set_timestamptz
@@ -309,10 +311,32 @@ func TrgeometryPoints(temp *Temporal) (_r0 *Set, _err error) {
 }
 
 
-// TrgeometryRotation wraps MEOS C function trgeometry_rotation.
-func TrgeometryRotation(temp *Temporal) (_r0 *Temporal, _err error) {
+// TrgeometryYaw wraps MEOS C function trgeometry_yaw.
+func TrgeometryYaw(temp *Temporal) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
-	_cret := C.trgeometry_rotation(temp._inner)
+	_cret := C.trgeometry_yaw(temp._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
+// TrgeometryPitch wraps MEOS C function trgeometry_pitch.
+func TrgeometryPitch(temp *Temporal) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.trgeometry_pitch(temp._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
+// TrgeometryRoll wraps MEOS C function trgeometry_roll.
+func TrgeometryRoll(temp *Temporal) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.trgeometry_roll(temp._inner)
 	if _err = meosError(); _err != nil {
 		return
 	}
@@ -574,6 +598,17 @@ func TrgeometryCumulativeLength(temp *Temporal) (_r0 *Temporal, _err error) {
 }
 
 
+// TrgeometryAngularSpeed wraps MEOS C function trgeometry_angular_speed.
+func TrgeometryAngularSpeed(temp *Temporal) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.trgeometry_angular_speed(temp._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TrgeometrySpeed wraps MEOS C function trgeometry_speed.
 func TrgeometrySpeed(temp *Temporal) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -662,6 +697,28 @@ func TrgeometryDeleteTstzspanset(temp *Temporal, ss *SpanSet, connect bool) (_r0
 }
 
 
+// TrgeometryMerge wraps MEOS C function trgeometry_merge.
+func TrgeometryMerge(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.trgeometry_merge(temp1._inner, temp2._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
+// TrgeometryMergeArray wraps MEOS C function trgeometry_merge_array.
+func TrgeometryMergeArray(temparr unsafe.Pointer, count int) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.trgeometry_merge_array((**C.Temporal)(unsafe.Pointer(temparr)), C.int(count))
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TrgeometryRound wraps MEOS C function trgeometry_round.
 func TrgeometryRound(temp *Temporal, maxdd int) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
@@ -974,6 +1031,28 @@ func TrgeometryMinusTstzspanset(temp *Temporal, ss *SpanSet) (_r0 *Temporal, _er
 }
 
 
+// TrgeometryAtElevation wraps MEOS C function trgeometry_at_elevation.
+func TrgeometryAtElevation(temp *Temporal, s *Span) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.trgeometry_at_elevation(temp._inner, s._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
+// TrgeometryMinusElevation wraps MEOS C function trgeometry_minus_elevation.
+func TrgeometryMinusElevation(temp *Temporal, s *Span) (_r0 *Temporal, _err error) {
+	C.meos_errno_reset()
+	_cret := C.trgeometry_minus_elevation(temp._inner, s._inner)
+	if _err = meosError(); _err != nil {
+		return
+	}
+	return &Temporal{_inner: _cret}, nil
+}
+
+
 // TdistanceTrgeometryGeo wraps MEOS C function tdistance_trgeometry_geo.
 func TdistanceTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) {
 	C.meos_errno_reset()
diff --git a/functions/types.go b/functions/types.go
index 3c54b13..1df0991 100644
--- a/functions/types.go
+++ b/functions/types.go
@@ -82,8 +82,6 @@ type AFFINE struct { _inner *C.AFFINE }
 func (x *AFFINE) Inner() *C.AFFINE { if x == nil { return nil }; return x._inner }
 type PJContext struct { _inner *C.PJ_CONTEXT }
 func (x *PJContext) Inner() *C.PJ_CONTEXT { if x == nil { return nil }; return x._inner }
-type GslRng struct { _inner *C.gsl_rng }
-func (x *GslRng) Inner() *C.gsl_rng { if x == nil { return nil }; return x._inner }
 
 // -------------------- enums --------------------
 type TempSubtype C.tempSubtype
@@ -100,11 +98,29 @@ const (
 	Interpolation_STEP Interpolation = 2
 	Interpolation_LINEAR Interpolation = 3
 )
-type RTreeSearchOp C.RTreeSearchOp
+type IndexSearchOp C.IndexSearchOp
 const (
-	RTreeSearchOp_RTREE_OVERLAPS RTreeSearchOp = 0
-	RTreeSearchOp_RTREE_CONTAINS RTreeSearchOp = 1
-	RTreeSearchOp_RTREE_CONTAINED_BY RTreeSearchOp = 2
+	IndexSearchOp_INDEX_OVERLAPS IndexSearchOp = 0
+	IndexSearchOp_INDEX_CONTAINS IndexSearchOp = 1
+	IndexSearchOp_INDEX_CONTAINED_BY IndexSearchOp = 2
+	IndexSearchOp_INDEX_LEFT IndexSearchOp = 3
+	IndexSearchOp_INDEX_OVERLEFT IndexSearchOp = 4
+	IndexSearchOp_INDEX_RIGHT IndexSearchOp = 5
+	IndexSearchOp_INDEX_OVERRIGHT IndexSearchOp = 6
+	IndexSearchOp_INDEX_BELOW IndexSearchOp = 7
+	IndexSearchOp_INDEX_OVERBELOW IndexSearchOp = 8
+	IndexSearchOp_INDEX_ABOVE IndexSearchOp = 9
+	IndexSearchOp_INDEX_OVERABOVE IndexSearchOp = 10
+	IndexSearchOp_INDEX_FRONT IndexSearchOp = 11
+	IndexSearchOp_INDEX_OVERFRONT IndexSearchOp = 12
+	IndexSearchOp_INDEX_BACK IndexSearchOp = 13
+	IndexSearchOp_INDEX_OVERBACK IndexSearchOp = 14
+	IndexSearchOp_INDEX_BEFORE IndexSearchOp = 15
+	IndexSearchOp_INDEX_OVERBEFORE IndexSearchOp = 16
+	IndexSearchOp_INDEX_AFTER IndexSearchOp = 17
+	IndexSearchOp_INDEX_OVERAFTER IndexSearchOp = 18
+	IndexSearchOp_INDEX_SAME IndexSearchOp = 19
+	IndexSearchOp_INDEX_ADJACENT IndexSearchOp = 20
 )
 type SPTreeKind C.SPTreeKind
 const (
@@ -195,7 +211,13 @@ const (
 	MeosType_T_TPCPATCH MeosType = 79
 	MeosType_T_TPCBOX MeosType = 80
 	MeosType_T_RAQUET MeosType = 81
-	MeosType_NUM_MEOS_TYPES MeosType = 82
+	MeosType_T_POSECHAIN MeosType = 82
+	MeosType_T_POSECHAINSET MeosType = 83
+	MeosType_T_TPOSECHAIN MeosType = 84
+	MeosType_T_S2CELL MeosType = 85
+	MeosType_T_S2CELLSET MeosType = 86
+	MeosType_T_TS2CELL MeosType = 87
+	MeosType_NUM_MEOS_TYPES MeosType = 88
 )
 type MeosOper C.MeosOper
 const (