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 (