diff --git a/example_pointer_boundary_test.go b/example_pointer_boundary_test.go
index a920f4e..c15e0ff 100644
--- a/example_pointer_boundary_test.go
+++ b/example_pointer_boundary_test.go
@@ -27,7 +27,7 @@ func ExampleTemporalFromPointer() {
 	// 3 <nil> Sequence <nil>
 }
 
-func ExampleTemporal_Pointer() {
+func Example_temporalPointer() {
 	tb := NewTBoolSeq("{FALSE@2022-10-01, TRUE@2022-10-03}")
 	crossed := functions.TemporalFromPointer(unsafe.Pointer(tb.Inner()))
 
diff --git a/example_types_io_test.go b/example_types_io_test.go
index 905b846..5cfcd4c 100644
--- a/example_types_io_test.go
+++ b/example_types_io_test.go
@@ -7,8 +7,8 @@ package gomeos
 // example_pointer_boundary_test.go does, through the pointer both share.
 
 import (
+	"bytes"
 	"fmt"
-	"unsafe"
 
 	"github.com/MobilityDB/GoMEOS/types"
 )
@@ -30,24 +30,33 @@ func ExampleTGeomPointFromEWKT() {
 
 func ExampleTGeomPointFromHexEWKB() {
 	point, _ := types.TGeomPointFromEWKT("SRID=4326;Point(1 1)@2024-12-06")
-	var size uint64 // the size_t the writer states the length in
-	hex, _ := point.AsHexEWKB(0, unsafe.Pointer(&size))
+	hex, _ := point.AsHexEWKB(0)
 	read, err := types.TGeomPointFromHexEWKB(hex)
 	fmt.Println(read, err)
 	// Output:
 	// POINT(1 1)@2024-12-06 00:00:00+00 <nil>
 }
 
-func ExampleCbuffer_String() {
+func Example_cbufferString() {
 	cbuffer, _ := types.CbufferFromText("Cbuffer(Point(1 1),0.5)")
 	fmt.Println(cbuffer)
 	// Output:
 	// Cbuffer(POINT(1 1),0.5)
 }
 
-func ExampleFloatSpan_String() {
+func Example_floatSpanString() {
 	span, _ := types.FloatSpanFromText("[8, 10]")
 	fmt.Println(span)
 	// Output:
 	// [8, 10]
 }
+
+func Example_temporalEWKB() {
+	point, _ := types.TGeomPointFromEWKT("SRID=4326;Point(1 1)@2024-12-06")
+	wkb, err := point.AsEWKB(0)
+	read, _ := types.TGeomPointFromEWKB(wkb)
+	again, _ := read.AsEWKB(0)
+	fmt.Println(len(wkb) > 0, err, bytes.Equal(wkb, again), read)
+	// Output:
+	// true <nil> true POINT(1 1)@2024-12-06 00:00:00+00
+}
diff --git a/functions/cgo.go b/functions/cgo.go
index 120ca4a..0be384a 100644
--- a/functions/cgo.go
+++ b/functions/cgo.go
@@ -22,6 +22,7 @@ package functions
 #cgo linux CFLAGS: -I/usr/include/h3
 
 #include <stddef.h>
+#include <stdlib.h>
 #include "meos.h"
 #include "meos_catalog.h"
 #include "meos_cbuffer.h"
@@ -50,7 +51,23 @@ package functions
 */
 import "C"
 
-import "fmt"
+import (
+	"fmt"
+	"unsafe"
+)
+
+// TakeBytes copies the n bytes a MEOS writer answered at p into Go memory and
+// frees MEOS's buffer, as every wrapper answering a char * frees it once
+// C.GoString has copied it (#_free_returned_string): the byte buffer of a WKB
+// writer, whose length MEOS states through its size_t * out-parameter, becomes
+// a []byte the caller owns. A nil buffer answers nil.
+func TakeBytes(p unsafe.Pointer, n uint64) []byte {
+	if p == nil {
+		return nil
+	}
+	defer C.free(p)
+	return C.GoBytes(p, C.int(n))
+}
 
 // MeosError reports that the MEOS call behind a wrapper failed, carrying the
 // error code MEOS recorded for it.
diff --git a/tools/codegen.py b/tools/codegen.py
index d1c0d31..34ba6a9 100644
--- a/tools/codegen.py
+++ b/tools/codegen.py
@@ -1166,11 +1166,28 @@ def _todo_stub(c_name: str, reason: str) -> str:
 #cgo linux CFLAGS: -I/usr/include/h3
 
 #include <stddef.h>
+#include <stdlib.h>
 @INCLUDES@
 */
 import "C"
 
-import "fmt"
+import (
+	"fmt"
+	"unsafe"
+)
+
+// TakeBytes copies the n bytes a MEOS writer answered at p into Go memory and
+// frees MEOS's buffer, as every wrapper answering a char * frees it once
+// C.GoString has copied it (#_free_returned_string): the byte buffer of a WKB
+// writer, whose length MEOS states through its size_t * out-parameter, becomes
+// a []byte the caller owns. A nil buffer answers nil.
+func TakeBytes(p unsafe.Pointer, n uint64) []byte {
+	if p == nil {
+		return nil
+	}
+	defer C.free(p)
+	return C.GoBytes(p, C.int(n))
+}
 
 // MeosError reports that the MEOS call behind a wrapper failed, carrying the
 // error code MEOS recorded for it.
diff --git a/tools/objectgen.py b/tools/objectgen.py
index 359cf00..4e74fb6 100644
--- a/tools/objectgen.py
+++ b/tools/objectgen.py
@@ -308,8 +308,42 @@ def method_for(self, cls: str, entry: dict) -> str | None:
         if params and self.class_of_handle(params[0][1]) in family:
             recv = params.pop(0)
 
+        # A byte buffer travels as a []byte, as MEOS.NET's method_for reads the
+        # catalog's shape: a `size_t *` the shape lists in `outParams` states the
+        # length of the buffer the call answers, so it leaves the signature and
+        # the buffer comes back as a []byte (functions.TakeBytes); a `uint8_t`
+        # array the shape lists in `inputArrays` is taken as a []byte, the
+        # parameter its length comes from filled with len().
+        shape = f.get("shape") or {}
+        length_out = next(
+            (codegen._go_param_name(p["name"]) for p in f.get("params", [])
+             if p["name"] in (shape.get("outParams") or [])
+             and p["cType"].replace(" ", "") == "size_t*"), None)
+        byte_inputs = {
+            codegen._go_param_name(a["param"]): codegen._go_param_name(a["lengthFrom"]["name"])
+            for a in shape.get("inputArrays") or []
+            if (a.get("element") or {}).get("c") == "uint8_t"
+            and (a.get("lengthFrom") or {}).get("kind") == "param"}
+        length_of = {length: arr for arr, length in byte_inputs.items()}
+        prelude = []
+
         args, decl = [], []
         for pname, ptype in params:
+            if pname == length_out:
+                prelude.append("\tvar _size uint64")
+                args.append("unsafe.Pointer(&_size)")
+                continue
+            if pname in byte_inputs:
+                local = f"_p_{pname}"
+                prelude.append(f"\tvar {local} unsafe.Pointer\n"
+                               f"\tif len({ident(pname)}) > 0 {{\n"
+                               f"\t\t{local} = unsafe.Pointer(&{ident(pname)}[0])\n\t}}")
+                decl.append(f"{ident(pname)} []byte")
+                args.append(local)
+                continue
+            if pname in length_of:
+                args.append(f"{self.qualify(ptype)}(len({ident(length_of[pname])}))")
+                continue
             mapped = self.map_param(ptype, ident(pname))
             if mapped is None:
                 self.deferred[cls].append(f"{oo}: parameter {pname} is {ptype}")
@@ -341,11 +375,19 @@ def method_for(self, cls: str, entry: dict) -> str | None:
         folded = (len(sig.returns) == 2 and sig.returns[0] == "bool"
                   and f["returnType"]["c"].replace("const ", "").strip() == "bool")
 
-        rets, body = [], []
+        rets, body = [], list(prelude)
         call = f"functions.{sig.go_name}({', '.join(args)})"
+        answers_bytes = (length_out is not None and sig.returns == ["unsafe.Pointer"]
+                         and f["returnType"]["c"].replace("const ", "").replace(" ", "")
+                         == "uint8_t*")
 
         if not sig.returns:
             body.append(f"\treturn {call}")
+        elif answers_bytes:
+            rets = ["[]byte"]
+            body.append(f"\t_r0, _err := {call}")
+            body.append("\tif _err != nil {\n\t\treturn nil, _err\n\t}")
+            body.append("\treturn functions.TakeBytes(_r0, _size), nil")
         elif folded:
             mapped = self.map_return(sig.returns[1], "_value")
             if mapped is None:
diff --git a/types/bigintset.go b/types/bigintset.go
index 062e50f..4e53774 100644
--- a/types/bigintset.go
+++ b/types/bigintset.go
@@ -122,8 +122,8 @@ func BigIntSetFromText(str string) (*BigIntSet, error) {
 }
 
 // BigIntSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func BigIntSetFromWKB(wkb unsafe.Pointer, size uint) (*BigIntSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func BigIntSetFromWKB(wkb []byte) (*BigIntSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/bigintspan.go b/types/bigintspan.go
index 230a001..8892102 100644
--- a/types/bigintspan.go
+++ b/types/bigintspan.go
@@ -155,8 +155,8 @@ func BigIntSpanFromText(str string) (*BigIntSpan, error) {
 }
 
 // BigIntSpanFromWKB is the portable fromWKB of MEOS span_from_wkb.
-func BigIntSpanFromWKB(wkb unsafe.Pointer, size uint) (*BigIntSpan, error) {
-	r, err := SpanFromWKB(wkb, size)
+func BigIntSpanFromWKB(wkb []byte) (*BigIntSpan, error) {
+	r, err := SpanFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/bigintspanset.go b/types/bigintspanset.go
index 605d571..ebba0d4 100644
--- a/types/bigintspanset.go
+++ b/types/bigintspanset.go
@@ -110,8 +110,8 @@ func BigIntSpanSetFromText(str string) (*BigIntSpanSet, error) {
 }
 
 // BigIntSpanSetFromWKB is the portable fromWKB of MEOS spanset_from_wkb.
-func BigIntSpanSetFromWKB(wkb unsafe.Pointer, size uint) (*BigIntSpanSet, error) {
-	r, err := SpanSetFromWKB(wkb, size)
+func BigIntSpanSetFromWKB(wkb []byte) (*BigIntSpanSet, error) {
+	r, err := SpanSetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/cbuffer.go b/types/cbuffer.go
index 4f1e1bc..cd85b1f 100644
--- a/types/cbuffer.go
+++ b/types/cbuffer.go
@@ -24,12 +24,13 @@ func CbufferFromPointer(p unsafe.Pointer) *Cbuffer {
 }
 
 // AsEWKB is MEOS cbuffer_as_ewkb.
-func (x *Cbuffer) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.CbufferAsEWKB(functions.CbufferFromPointer(x.Pointer()), variant, size_out)
+func (x *Cbuffer) AsEWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.CbufferAsEWKB(functions.CbufferFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // AsEWKT is MEOS cbuffer_as_ewkt.
@@ -42,8 +43,9 @@ func (x *Cbuffer) AsEWKT(maxdd int) (string, error) {
 }
 
 // AsHexEWKB is MEOS cbuffer_as_hexewkb.
-func (x *Cbuffer) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.CbufferAsHexewkb(functions.CbufferFromPointer(x.Pointer()), variant, size_out)
+func (x *Cbuffer) AsHexEWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.CbufferAsHexewkb(functions.CbufferFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -51,8 +53,9 @@ func (x *Cbuffer) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, err
 }
 
 // AsHexWKB is MEOS cbuffer_as_hexwkb.
-func (x *Cbuffer) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.CbufferAsHexwkb(functions.CbufferFromPointer(x.Pointer()), variant, size_out)
+func (x *Cbuffer) AsHexWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.CbufferAsHexwkb(functions.CbufferFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -69,12 +72,13 @@ func (x *Cbuffer) AsText(maxdd int) (string, error) {
 }
 
 // AsWKB is MEOS cbuffer_as_wkb.
-func (x *Cbuffer) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.CbufferAsWKB(functions.CbufferFromPointer(x.Pointer()), variant, size_out)
+func (x *Cbuffer) AsWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.CbufferAsWKB(functions.CbufferFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // CbufferFromHexWKB is MEOS cbuffer_from_hexwkb.
@@ -87,8 +91,12 @@ func CbufferFromHexWKB(hexwkb string) (*Cbuffer, error) {
 }
 
 // CbufferFromWKB is MEOS cbuffer_from_wkb.
-func CbufferFromWKB(wkb unsafe.Pointer, size uint) (*Cbuffer, error) {
-	_r0, _err := functions.CbufferFromWKB(wkb, size)
+func CbufferFromWKB(wkb []byte) (*Cbuffer, error) {
+	var _p_wkb unsafe.Pointer
+	if len(wkb) > 0 {
+		_p_wkb = unsafe.Pointer(&wkb[0])
+	}
+	_r0, _err := functions.CbufferFromWKB(_p_wkb, uint(len(wkb)))
 	if _err != nil {
 		return nil, _err
 	}
@@ -330,8 +338,8 @@ func (x *Cbuffer) ToSet() (*Set, error) {
 }
 
 // CbufferFromEWKB is the portable fromEWKB of MEOS cbuffer_from_wkb.
-func CbufferFromEWKB(wkb unsafe.Pointer, size uint) (*Cbuffer, error) {
-	return CbufferFromWKB(wkb, size)
+func CbufferFromEWKB(wkb []byte) (*Cbuffer, error) {
+	return CbufferFromWKB(wkb)
 }
 
 // CbufferFromEWKT is the portable fromEWKT of MEOS cbuffer_in.
diff --git a/types/cbufferset.go b/types/cbufferset.go
index 727dab4..da464fe 100644
--- a/types/cbufferset.go
+++ b/types/cbufferset.go
@@ -90,8 +90,8 @@ func (x *CbufferSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) {
 }
 
 // CbufferSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb.
-func CbufferSetFromEWKB(wkb unsafe.Pointer, size uint) (*CbufferSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func CbufferSetFromEWKB(wkb []byte) (*CbufferSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -135,8 +135,8 @@ func CbufferSetFromText(str string) (*CbufferSet, error) {
 }
 
 // CbufferSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func CbufferSetFromWKB(wkb unsafe.Pointer, size uint) (*CbufferSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func CbufferSetFromWKB(wkb []byte) (*CbufferSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/dateset.go b/types/dateset.go
index cce1e70..974516d 100644
--- a/types/dateset.go
+++ b/types/dateset.go
@@ -131,8 +131,8 @@ func DateSetFromText(str string) (*DateSet, error) {
 }
 
 // DateSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func DateSetFromWKB(wkb unsafe.Pointer, size uint) (*DateSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func DateSetFromWKB(wkb []byte) (*DateSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/datespan.go b/types/datespan.go
index 10cbb01..6dcb8a2 100644
--- a/types/datespan.go
+++ b/types/datespan.go
@@ -110,8 +110,8 @@ func DateSpanFromText(str string) (*DateSpan, error) {
 }
 
 // DateSpanFromWKB is the portable fromWKB of MEOS span_from_wkb.
-func DateSpanFromWKB(wkb unsafe.Pointer, size uint) (*DateSpan, error) {
-	r, err := SpanFromWKB(wkb, size)
+func DateSpanFromWKB(wkb []byte) (*DateSpan, error) {
+	r, err := SpanFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/datespanset.go b/types/datespanset.go
index f690349..5b9db4f 100644
--- a/types/datespanset.go
+++ b/types/datespanset.go
@@ -149,8 +149,8 @@ func DateSpanSetFromText(str string) (*DateSpanSet, error) {
 }
 
 // DateSpanSetFromWKB is the portable fromWKB of MEOS spanset_from_wkb.
-func DateSpanSetFromWKB(wkb unsafe.Pointer, size uint) (*DateSpanSet, error) {
-	r, err := SpanSetFromWKB(wkb, size)
+func DateSpanSetFromWKB(wkb []byte) (*DateSpanSet, error) {
+	r, err := SpanSetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/floatset.go b/types/floatset.go
index 2f4153a..fac4ee6 100644
--- a/types/floatset.go
+++ b/types/floatset.go
@@ -167,8 +167,8 @@ func FloatSetFromText(str string) (*FloatSet, error) {
 }
 
 // FloatSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func FloatSetFromWKB(wkb unsafe.Pointer, size uint) (*FloatSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func FloatSetFromWKB(wkb []byte) (*FloatSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/floatspan.go b/types/floatspan.go
index 4d8f566..197c942 100644
--- a/types/floatspan.go
+++ b/types/floatspan.go
@@ -200,8 +200,8 @@ func FloatSpanFromText(str string) (*FloatSpan, error) {
 }
 
 // FloatSpanFromWKB is the portable fromWKB of MEOS span_from_wkb.
-func FloatSpanFromWKB(wkb unsafe.Pointer, size uint) (*FloatSpan, error) {
-	r, err := SpanFromWKB(wkb, size)
+func FloatSpanFromWKB(wkb []byte) (*FloatSpan, error) {
+	r, err := SpanFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/floatspanset.go b/types/floatspanset.go
index 2202221..6eac627 100644
--- a/types/floatspanset.go
+++ b/types/floatspanset.go
@@ -164,8 +164,8 @@ func FloatSpanSetFromText(str string) (*FloatSpanSet, error) {
 }
 
 // FloatSpanSetFromWKB is the portable fromWKB of MEOS spanset_from_wkb.
-func FloatSpanSetFromWKB(wkb unsafe.Pointer, size uint) (*FloatSpanSet, error) {
-	r, err := SpanSetFromWKB(wkb, size)
+func FloatSpanSetFromWKB(wkb []byte) (*FloatSpanSet, error) {
+	r, err := SpanSetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/geo.go b/types/geo.go
index 3c29aae..9fc2426 100644
--- a/types/geo.go
+++ b/types/geo.go
@@ -24,12 +24,13 @@ func GeoFromPointer(p unsafe.Pointer) *Geo {
 }
 
 // GeoAsEWKB is MEOS geo_as_ewkb.
-func GeoAsEWKB(gs *TRGeometrySeqSet, endian *string, size unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.GeoAsEWKB(functions.GeomFromPointer(gs.Pointer()), endian, size)
+func GeoAsEWKB(gs *TRGeometrySeqSet, endian *string) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.GeoAsEWKB(functions.GeomFromPointer(gs.Pointer()), endian, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // GeoAsEWKT is MEOS geo_as_ewkt.
@@ -69,8 +70,12 @@ func GeoAsText(gs *TRGeometrySeqSet, precision int) (string, error) {
 }
 
 // GeoFromEWKB is MEOS geo_from_ewkb.
-func GeoFromEWKB(wkb unsafe.Pointer, wkb_size uint, srid int32) (*TRGeometrySeqSet, error) {
-	_r0, _err := functions.GeoFromEWKB(wkb, wkb_size, srid)
+func GeoFromEWKB(wkb []byte, srid int32) (*TRGeometrySeqSet, error) {
+	var _p_wkb unsafe.Pointer
+	if len(wkb) > 0 {
+		_p_wkb = unsafe.Pointer(&wkb[0])
+	}
+	_r0, _err := functions.GeoFromEWKB(_p_wkb, uint(len(wkb)), srid)
 	if _err != nil {
 		return nil, _err
 	}
diff --git a/types/geography.go b/types/geography.go
index d16a645..28c39a5 100644
--- a/types/geography.go
+++ b/types/geography.go
@@ -141,8 +141,8 @@ func GeographyShortestline(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet, use_sph
 }
 
 // GeographyFromEWKB is the portable fromEWKB of MEOS geo_from_ewkb.
-func GeographyFromEWKB(wkb unsafe.Pointer, wkb_size uint, srid int32) (*TRGeometrySeqSet, error) {
-	return GeoFromEWKB(wkb, wkb_size, srid)
+func GeographyFromEWKB(wkb []byte, srid int32) (*TRGeometrySeqSet, error) {
+	return GeoFromEWKB(wkb, srid)
 }
 
 // GeographyFromMFJSON is the portable fromMFJSON of MEOS geo_from_geojson.
diff --git a/types/geogset.go b/types/geogset.go
index 804a7ca..f8b0755 100644
--- a/types/geogset.go
+++ b/types/geogset.go
@@ -33,8 +33,8 @@ func GeogSetIn(str string) (*Set, error) {
 }
 
 // GeogSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb.
-func GeogSetFromEWKB(wkb unsafe.Pointer, size uint) (*GeogSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func GeogSetFromEWKB(wkb []byte) (*GeogSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -78,8 +78,8 @@ func GeogSetFromText(str string) (*GeogSet, error) {
 }
 
 // GeogSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func GeogSetFromWKB(wkb unsafe.Pointer, size uint) (*GeogSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func GeogSetFromWKB(wkb []byte) (*GeogSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/geometry.go b/types/geometry.go
index d29f1e0..28f826d 100644
--- a/types/geometry.go
+++ b/types/geometry.go
@@ -441,8 +441,8 @@ func GeometryTposeToTrgeometry(gs *TRGeometrySeqSet, temp *Temporal) (*Temporal,
 }
 
 // GeometryFromEWKB is the portable fromEWKB of MEOS geo_from_ewkb.
-func GeometryFromEWKB(wkb unsafe.Pointer, wkb_size uint, srid int32) (*TRGeometrySeqSet, error) {
-	return GeoFromEWKB(wkb, wkb_size, srid)
+func GeometryFromEWKB(wkb []byte, srid int32) (*TRGeometrySeqSet, error) {
+	return GeoFromEWKB(wkb, srid)
 }
 
 // GeometryFromMFJSON is the portable fromMFJSON of MEOS geo_from_geojson.
diff --git a/types/geomset.go b/types/geomset.go
index 6433c84..86bb65d 100644
--- a/types/geomset.go
+++ b/types/geomset.go
@@ -33,8 +33,8 @@ func GeomSetIn(str string) (*Set, error) {
 }
 
 // GeomSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb.
-func GeomSetFromEWKB(wkb unsafe.Pointer, size uint) (*GeomSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func GeomSetFromEWKB(wkb []byte) (*GeomSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -78,8 +78,8 @@ func GeomSetFromText(str string) (*GeomSet, error) {
 }
 
 // GeomSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func GeomSetFromWKB(wkb unsafe.Pointer, size uint) (*GeomSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func GeomSetFromWKB(wkb []byte) (*GeomSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/h3indexset.go b/types/h3indexset.go
index b9d74c8..3cdfe82 100644
--- a/types/h3indexset.go
+++ b/types/h3indexset.go
@@ -108,8 +108,8 @@ func (x *H3IndexSet) CoverCells(resolution int32) (*Set, error) {
 }
 
 // H3IndexSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb.
-func H3IndexSetFromEWKB(wkb unsafe.Pointer, size uint) (*H3IndexSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func H3IndexSetFromEWKB(wkb []byte) (*H3IndexSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -153,8 +153,8 @@ func H3IndexSetFromText(str string) (*H3IndexSet, error) {
 }
 
 // H3IndexSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func H3IndexSetFromWKB(wkb unsafe.Pointer, size uint) (*H3IndexSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func H3IndexSetFromWKB(wkb []byte) (*H3IndexSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/intset.go b/types/intset.go
index 842508a..b2ee352 100644
--- a/types/intset.go
+++ b/types/intset.go
@@ -131,8 +131,8 @@ func IntSetFromText(str string) (*IntSet, error) {
 }
 
 // IntSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func IntSetFromWKB(wkb unsafe.Pointer, size uint) (*IntSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func IntSetFromWKB(wkb []byte) (*IntSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/intspan.go b/types/intspan.go
index ab72d58..6c02bd6 100644
--- a/types/intspan.go
+++ b/types/intspan.go
@@ -155,8 +155,8 @@ func IntSpanFromText(str string) (*IntSpan, error) {
 }
 
 // IntSpanFromWKB is the portable fromWKB of MEOS span_from_wkb.
-func IntSpanFromWKB(wkb unsafe.Pointer, size uint) (*IntSpan, error) {
-	r, err := SpanFromWKB(wkb, size)
+func IntSpanFromWKB(wkb []byte) (*IntSpan, error) {
+	r, err := SpanFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/intspanset.go b/types/intspanset.go
index a0a2b15..22b1892 100644
--- a/types/intspanset.go
+++ b/types/intspanset.go
@@ -119,8 +119,8 @@ func IntSpanSetFromText(str string) (*IntSpanSet, error) {
 }
 
 // IntSpanSetFromWKB is the portable fromWKB of MEOS spanset_from_wkb.
-func IntSpanSetFromWKB(wkb unsafe.Pointer, size uint) (*IntSpanSet, error) {
-	r, err := SpanSetFromWKB(wkb, size)
+func IntSpanSetFromWKB(wkb []byte) (*IntSpanSet, error) {
+	r, err := SpanSetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/jsonbset.go b/types/jsonbset.go
index b5f9060..0a7512e 100644
--- a/types/jsonbset.go
+++ b/types/jsonbset.go
@@ -356,8 +356,8 @@ func JsonbSetFromText(str string) (*JsonbSet, error) {
 }
 
 // JsonbSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func JsonbSetFromWKB(wkb unsafe.Pointer, size uint) (*JsonbSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func JsonbSetFromWKB(wkb []byte) (*JsonbSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/npoint.go b/types/npoint.go
index 6f5b058..7be8531 100644
--- a/types/npoint.go
+++ b/types/npoint.go
@@ -24,12 +24,13 @@ func NpointFromPointer(p unsafe.Pointer) *Npoint {
 }
 
 // AsEWKB is MEOS npoint_as_ewkb.
-func (x *Npoint) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.NpointAsEWKB(functions.NpointFromPointer(x.Pointer()), variant, size_out)
+func (x *Npoint) AsEWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.NpointAsEWKB(functions.NpointFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // AsEWKT is MEOS npoint_as_ewkt.
@@ -42,8 +43,9 @@ func (x *Npoint) AsEWKT(maxdd int) (string, error) {
 }
 
 // AsHexEWKB is MEOS npoint_as_hexewkb.
-func (x *Npoint) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.NpointAsHexewkb(functions.NpointFromPointer(x.Pointer()), variant, size_out)
+func (x *Npoint) AsHexEWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.NpointAsHexewkb(functions.NpointFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -51,8 +53,9 @@ func (x *Npoint) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, erro
 }
 
 // AsHexWKB is MEOS npoint_as_hexwkb.
-func (x *Npoint) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.NpointAsHexwkb(functions.NpointFromPointer(x.Pointer()), variant, size_out)
+func (x *Npoint) AsHexWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.NpointAsHexwkb(functions.NpointFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -69,12 +72,13 @@ func (x *Npoint) AsText(maxdd int) (string, error) {
 }
 
 // AsWKB is MEOS npoint_as_wkb.
-func (x *Npoint) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.NpointAsWKB(functions.NpointFromPointer(x.Pointer()), variant, size_out)
+func (x *Npoint) AsWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.NpointAsWKB(functions.NpointFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // NpointFromHexWKB is MEOS npoint_from_hexwkb.
@@ -87,8 +91,12 @@ func NpointFromHexWKB(hexwkb string) (*Npoint, error) {
 }
 
 // NpointFromWKB is MEOS npoint_from_wkb.
-func NpointFromWKB(wkb unsafe.Pointer, size uint) (*Npoint, error) {
-	_r0, _err := functions.NpointFromWKB(wkb, size)
+func NpointFromWKB(wkb []byte) (*Npoint, error) {
+	var _p_wkb unsafe.Pointer
+	if len(wkb) > 0 {
+		_p_wkb = unsafe.Pointer(&wkb[0])
+	}
+	_r0, _err := functions.NpointFromWKB(_p_wkb, uint(len(wkb)))
 	if _err != nil {
 		return nil, _err
 	}
@@ -303,8 +311,8 @@ func (x *Npoint) ToSet() (*Set, error) {
 }
 
 // NpointFromEWKB is the portable fromEWKB of MEOS npoint_from_wkb.
-func NpointFromEWKB(wkb unsafe.Pointer, size uint) (*Npoint, error) {
-	return NpointFromWKB(wkb, size)
+func NpointFromEWKB(wkb []byte) (*Npoint, error) {
+	return NpointFromWKB(wkb)
 }
 
 // NpointFromEWKT is the portable fromEWKT of MEOS npoint_in.
diff --git a/types/npointset.go b/types/npointset.go
index 633fd06..0317bc4 100644
--- a/types/npointset.go
+++ b/types/npointset.go
@@ -99,8 +99,8 @@ func (x *NpointSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) {
 }
 
 // NpointSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb.
-func NpointSetFromEWKB(wkb unsafe.Pointer, size uint) (*NpointSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func NpointSetFromEWKB(wkb []byte) (*NpointSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -144,8 +144,8 @@ func NpointSetFromText(str string) (*NpointSet, error) {
 }
 
 // NpointSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func NpointSetFromWKB(wkb unsafe.Pointer, size uint) (*NpointSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func NpointSetFromWKB(wkb []byte) (*NpointSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/nsegment.go b/types/nsegment.go
index 7829954..e164d84 100644
--- a/types/nsegment.go
+++ b/types/nsegment.go
@@ -24,8 +24,9 @@ func NsegmentFromPointer(p unsafe.Pointer) *Nsegment {
 }
 
 // AsHexEWKB is MEOS nsegment_as_hexewkb.
-func (x *Nsegment) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.NsegmentAsHexewkb(functions.NsegmentFromPointer(x.Pointer()), variant, size_out)
+func (x *Nsegment) AsHexEWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.NsegmentAsHexewkb(functions.NsegmentFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -33,8 +34,9 @@ func (x *Nsegment) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, er
 }
 
 // AsHexWKB is MEOS nsegment_as_hexwkb.
-func (x *Nsegment) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.NsegmentAsHexwkb(functions.NsegmentFromPointer(x.Pointer()), variant, size_out)
+func (x *Nsegment) AsHexWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.NsegmentAsHexwkb(functions.NsegmentFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -42,12 +44,13 @@ func (x *Nsegment) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, err
 }
 
 // AsWKB is MEOS nsegment_as_wkb.
-func (x *Nsegment) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.NsegmentAsWKB(functions.NsegmentFromPointer(x.Pointer()), variant, size_out)
+func (x *Nsegment) AsWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.NsegmentAsWKB(functions.NsegmentFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // NsegmentFromHexWKB is MEOS nsegment_from_hexwkb.
@@ -60,8 +63,12 @@ func NsegmentFromHexWKB(hexwkb string) (*Nsegment, error) {
 }
 
 // NsegmentFromWKB is MEOS nsegment_from_wkb.
-func NsegmentFromWKB(wkb unsafe.Pointer, size uint) (*Nsegment, error) {
-	_r0, _err := functions.NsegmentFromWKB(wkb, size)
+func NsegmentFromWKB(wkb []byte) (*Nsegment, error) {
+	var _p_wkb unsafe.Pointer
+	if len(wkb) > 0 {
+		_p_wkb = unsafe.Pointer(&wkb[0])
+	}
+	_r0, _err := functions.NsegmentFromWKB(_p_wkb, uint(len(wkb)))
 	if _err != nil {
 		return nil, _err
 	}
@@ -87,12 +94,13 @@ func (x *Nsegment) Out(maxdd int) (string, error) {
 }
 
 // AsEWKB is MEOS nsegment_as_ewkb.
-func (x *Nsegment) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.NsegmentAsEWKB(functions.NsegmentFromPointer(x.Pointer()), variant, size_out)
+func (x *Nsegment) AsEWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.NsegmentAsEWKB(functions.NsegmentFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // AsEWKT is MEOS nsegment_as_ewkt.
@@ -258,8 +266,8 @@ func (x *Nsegment) Ne(ns2 *Nsegment) (bool, error) {
 }
 
 // NsegmentFromEWKB is the portable fromEWKB of MEOS nsegment_from_wkb.
-func NsegmentFromEWKB(wkb unsafe.Pointer, size uint) (*Nsegment, error) {
-	return NsegmentFromWKB(wkb, size)
+func NsegmentFromEWKB(wkb []byte) (*Nsegment, error) {
+	return NsegmentFromWKB(wkb)
 }
 
 // NsegmentFromEWKT is the portable fromEWKT of MEOS nsegment_in.
diff --git a/types/pcpatchset.go b/types/pcpatchset.go
index f3074b1..311eee0 100644
--- a/types/pcpatchset.go
+++ b/types/pcpatchset.go
@@ -90,8 +90,8 @@ func (x *PcpatchSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) {
 }
 
 // PcpatchSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb.
-func PcpatchSetFromEWKB(wkb unsafe.Pointer, size uint) (*PcpatchSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func PcpatchSetFromEWKB(wkb []byte) (*PcpatchSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -135,8 +135,8 @@ func PcpatchSetFromText(str string) (*PcpatchSet, error) {
 }
 
 // PcpatchSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func PcpatchSetFromWKB(wkb unsafe.Pointer, size uint) (*PcpatchSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func PcpatchSetFromWKB(wkb []byte) (*PcpatchSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/pcpointset.go b/types/pcpointset.go
index d1cdde3..033bf24 100644
--- a/types/pcpointset.go
+++ b/types/pcpointset.go
@@ -90,8 +90,8 @@ func (x *PcpointSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) {
 }
 
 // PcpointSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb.
-func PcpointSetFromEWKB(wkb unsafe.Pointer, size uint) (*PcpointSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func PcpointSetFromEWKB(wkb []byte) (*PcpointSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -135,8 +135,8 @@ func PcpointSetFromText(str string) (*PcpointSet, error) {
 }
 
 // PcpointSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func PcpointSetFromWKB(wkb unsafe.Pointer, size uint) (*PcpointSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func PcpointSetFromWKB(wkb []byte) (*PcpointSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/pose.go b/types/pose.go
index 7e6a844..8a314d5 100644
--- a/types/pose.go
+++ b/types/pose.go
@@ -24,12 +24,13 @@ func PoseFromPointer(p unsafe.Pointer) *Pose {
 }
 
 // AsEWKB is MEOS pose_as_ewkb.
-func (x *Pose) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.PoseAsEWKB(functions.PoseFromPointer(x.Pointer()), variant, size_out)
+func (x *Pose) AsEWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.PoseAsEWKB(functions.PoseFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // AsEWKT is MEOS pose_as_ewkt.
@@ -42,8 +43,9 @@ func (x *Pose) AsEWKT(maxdd int) (string, error) {
 }
 
 // AsHexEWKB is MEOS pose_as_hexewkb.
-func (x *Pose) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.PoseAsHexewkb(functions.PoseFromPointer(x.Pointer()), variant, size_out)
+func (x *Pose) AsHexEWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.PoseAsHexewkb(functions.PoseFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -51,8 +53,9 @@ func (x *Pose) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error)
 }
 
 // AsHexWKB is MEOS pose_as_hexwkb.
-func (x *Pose) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.PoseAsHexwkb(functions.PoseFromPointer(x.Pointer()), variant, size_out)
+func (x *Pose) AsHexWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.PoseAsHexwkb(functions.PoseFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -69,17 +72,22 @@ func (x *Pose) AsText(maxdd int) (string, error) {
 }
 
 // AsWKB is MEOS pose_as_wkb.
-func (x *Pose) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.PoseAsWKB(functions.PoseFromPointer(x.Pointer()), variant, size_out)
+func (x *Pose) AsWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.PoseAsWKB(functions.PoseFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // PoseFromWKB is MEOS pose_from_wkb.
-func PoseFromWKB(wkb unsafe.Pointer, size uint) (*Pose, error) {
-	_r0, _err := functions.PoseFromWKB(wkb, size)
+func PoseFromWKB(wkb []byte) (*Pose, error) {
+	var _p_wkb unsafe.Pointer
+	if len(wkb) > 0 {
+		_p_wkb = unsafe.Pointer(&wkb[0])
+	}
+	_r0, _err := functions.PoseFromWKB(_p_wkb, uint(len(wkb)))
 	if _err != nil {
 		return nil, _err
 	}
@@ -483,8 +491,8 @@ func (x *Pose) ToPosechain() (unsafe.Pointer, error) {
 }
 
 // PoseFromEWKB is the portable fromEWKB of MEOS pose_from_wkb.
-func PoseFromEWKB(wkb unsafe.Pointer, size uint) (*Pose, error) {
-	return PoseFromWKB(wkb, size)
+func PoseFromEWKB(wkb []byte) (*Pose, error) {
+	return PoseFromWKB(wkb)
 }
 
 // PoseFromEWKT is the portable fromEWKT of MEOS pose_from_text.
diff --git a/types/posechain.go b/types/posechain.go
index be4000f..6218370 100644
--- a/types/posechain.go
+++ b/types/posechain.go
@@ -51,12 +51,13 @@ func PoseChainAsText(pc unsafe.Pointer, maxdd int) (string, error) {
 }
 
 // PoseChainAsEWKB is MEOS posechain_as_ewkb.
-func PoseChainAsEWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.PosechainAsEWKB(pc, variant, size_out)
+func PoseChainAsEWKB(pc unsafe.Pointer, variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.PosechainAsEWKB(pc, variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // PoseChainAsEWKT is MEOS posechain_as_ewkt.
@@ -69,17 +70,19 @@ func PoseChainAsEWKT(pc unsafe.Pointer, maxdd int) (string, error) {
 }
 
 // PoseChainAsWKB is MEOS posechain_as_wkb.
-func PoseChainAsWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.PosechainAsWKB(pc, variant, size_out)
+func PoseChainAsWKB(pc unsafe.Pointer, variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.PosechainAsWKB(pc, variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // PoseChainAsHexEWKB is MEOS posechain_as_hexewkb.
-func PoseChainAsHexEWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.PosechainAsHexewkb(pc, variant, size_out)
+func PoseChainAsHexEWKB(pc unsafe.Pointer, variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.PosechainAsHexewkb(pc, variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -87,8 +90,9 @@ func PoseChainAsHexEWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointe
 }
 
 // PoseChainAsHexWKB is MEOS posechain_as_hexwkb.
-func PoseChainAsHexWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.PosechainAsHexwkb(pc, variant, size_out)
+func PoseChainAsHexWKB(pc unsafe.Pointer, variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.PosechainAsHexwkb(pc, variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -96,8 +100,12 @@ func PoseChainAsHexWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointer
 }
 
 // PoseChainFromWKB is MEOS posechain_from_wkb.
-func PoseChainFromWKB(wkb unsafe.Pointer, size uint) (unsafe.Pointer, error) {
-	_r0, _err := functions.PosechainFromWKB(wkb, size)
+func PoseChainFromWKB(wkb []byte) (unsafe.Pointer, error) {
+	var _p_wkb unsafe.Pointer
+	if len(wkb) > 0 {
+		_p_wkb = unsafe.Pointer(&wkb[0])
+	}
+	_r0, _err := functions.PosechainFromWKB(_p_wkb, uint(len(wkb)))
 	if _err != nil {
 		return nil, _err
 	}
@@ -384,8 +392,8 @@ func PoseChainToSet(pc unsafe.Pointer) (*Set, error) {
 }
 
 // PoseChainFromEWKB is the portable fromEWKB of MEOS posechain_from_wkb.
-func PoseChainFromEWKB(wkb unsafe.Pointer, size uint) (unsafe.Pointer, error) {
-	return PoseChainFromWKB(wkb, size)
+func PoseChainFromEWKB(wkb []byte) (unsafe.Pointer, error) {
+	return PoseChainFromWKB(wkb)
 }
 
 // PoseChainFromEWKT is the portable fromEWKT of MEOS posechain_in.
diff --git a/types/posechainset.go b/types/posechainset.go
index 31f9400..f1f9aa4 100644
--- a/types/posechainset.go
+++ b/types/posechainset.go
@@ -78,8 +78,8 @@ func (x *PoseChainSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) {
 }
 
 // PoseChainSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb.
-func PoseChainSetFromEWKB(wkb unsafe.Pointer, size uint) (*PoseChainSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func PoseChainSetFromEWKB(wkb []byte) (*PoseChainSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -123,8 +123,8 @@ func PoseChainSetFromText(str string) (*PoseChainSet, error) {
 }
 
 // PoseChainSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func PoseChainSetFromWKB(wkb unsafe.Pointer, size uint) (*PoseChainSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func PoseChainSetFromWKB(wkb []byte) (*PoseChainSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/poseset.go b/types/poseset.go
index a539738..3d603ed 100644
--- a/types/poseset.go
+++ b/types/poseset.go
@@ -90,8 +90,8 @@ func (x *PoseSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) {
 }
 
 // PoseSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb.
-func PoseSetFromEWKB(wkb unsafe.Pointer, size uint) (*PoseSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func PoseSetFromEWKB(wkb []byte) (*PoseSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -135,8 +135,8 @@ func PoseSetFromText(str string) (*PoseSet, error) {
 }
 
 // PoseSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func PoseSetFromWKB(wkb unsafe.Pointer, size uint) (*PoseSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func PoseSetFromWKB(wkb []byte) (*PoseSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/quadbinset.go b/types/quadbinset.go
index 4e588c9..9ac82bb 100644
--- a/types/quadbinset.go
+++ b/types/quadbinset.go
@@ -126,8 +126,8 @@ func (x *QuadbinSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) {
 }
 
 // QuadbinSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb.
-func QuadbinSetFromEWKB(wkb unsafe.Pointer, size uint) (*QuadbinSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func QuadbinSetFromEWKB(wkb []byte) (*QuadbinSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -171,8 +171,8 @@ func QuadbinSetFromText(str string) (*QuadbinSet, error) {
 }
 
 // QuadbinSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func QuadbinSetFromWKB(wkb unsafe.Pointer, size uint) (*QuadbinSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func QuadbinSetFromWKB(wkb []byte) (*QuadbinSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/raquet.go b/types/raquet.go
index 20d39e4..a8cb689 100644
--- a/types/raquet.go
+++ b/types/raquet.go
@@ -60,8 +60,12 @@ func RaquetOut(rq unsafe.Pointer) (string, error) {
 }
 
 // RaquetFromWKB is MEOS raquet_from_wkb.
-func RaquetFromWKB(wkb unsafe.Pointer, size uint) (unsafe.Pointer, error) {
-	_r0, _err := functions.RaquetFromWKB(wkb, size)
+func RaquetFromWKB(wkb []byte) (unsafe.Pointer, error) {
+	var _p_wkb unsafe.Pointer
+	if len(wkb) > 0 {
+		_p_wkb = unsafe.Pointer(&wkb[0])
+	}
+	_r0, _err := functions.RaquetFromWKB(_p_wkb, uint(len(wkb)))
 	if _err != nil {
 		return nil, _err
 	}
@@ -78,17 +82,19 @@ func RaquetFromHexWKB(hexwkb string) (unsafe.Pointer, error) {
 }
 
 // RaquetAsWKB is MEOS raquet_as_wkb.
-func RaquetAsWKB(rq unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.RaquetAsWKB(rq, variant, size_out)
+func RaquetAsWKB(rq unsafe.Pointer, variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.RaquetAsWKB(rq, variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // RaquetAsHexWKB is MEOS raquet_as_hexwkb.
-func RaquetAsHexWKB(rq unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.RaquetAsHexwkb(rq, variant, size_out)
+func RaquetAsHexWKB(rq unsafe.Pointer, variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.RaquetAsHexwkb(rq, variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -96,8 +102,12 @@ func RaquetAsHexWKB(rq unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (
 }
 
 // RaquetMake is MEOS raquet_make.
-func RaquetMake(quadbin uint64, width int32, height int32, pixtype functions.MeosPixType, nodata float64, has_nodata bool, pixels unsafe.Pointer, pixels_size uint) (unsafe.Pointer, error) {
-	_r0, _err := functions.RaquetMake(quadbin, width, height, pixtype, nodata, has_nodata, pixels, pixels_size)
+func RaquetMake(quadbin uint64, width int32, height int32, pixtype functions.MeosPixType, nodata float64, has_nodata bool, pixels []byte) (unsafe.Pointer, error) {
+	var _p_pixels unsafe.Pointer
+	if len(pixels) > 0 {
+		_p_pixels = unsafe.Pointer(&pixels[0])
+	}
+	_r0, _err := functions.RaquetMake(quadbin, width, height, pixtype, nodata, has_nodata, _p_pixels, uint(len(pixels)))
 	if _err != nil {
 		return nil, _err
 	}
@@ -123,8 +133,12 @@ func RaquetRead(path string, quadbin uint64) (unsafe.Pointer, error) {
 }
 
 // RaquetReadBytes is MEOS raquet_read_bytes.
-func RaquetReadBytes(data unsafe.Pointer, size uint, quadbin uint64) (unsafe.Pointer, error) {
-	_r0, _err := functions.RaquetReadBytes(data, size, quadbin)
+func RaquetReadBytes(data []byte, quadbin uint64) (unsafe.Pointer, error) {
+	var _p_data unsafe.Pointer
+	if len(data) > 0 {
+		_p_data = unsafe.Pointer(&data[0])
+	}
+	_r0, _err := functions.RaquetReadBytes(_p_data, uint(len(data)), quadbin)
 	if _err != nil {
 		return nil, _err
 	}
@@ -189,12 +203,13 @@ func RaquetBandNodataValue(rq unsafe.Pointer) (float64, bool, error) {
 }
 
 // RaquetPixels is MEOS raquet_pixels.
-func RaquetPixels(rq unsafe.Pointer, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.RaquetPixels(rq, size_out)
+func RaquetPixels(rq unsafe.Pointer) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.RaquetPixels(rq, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // RaquetHash is MEOS raquet_hash.
diff --git a/types/raster.go b/types/raster.go
index 8c21e71..4d81246 100644
--- a/types/raster.go
+++ b/types/raster.go
@@ -24,8 +24,12 @@ func RasterFromPointer(p unsafe.Pointer) *Raster {
 }
 
 // RasterFromWKB is MEOS raster_from_wkb.
-func RasterFromWKB(wkb unsafe.Pointer, size uint) (unsafe.Pointer, error) {
-	_r0, _err := functions.RasterFromWKB(wkb, size)
+func RasterFromWKB(wkb []byte) (unsafe.Pointer, error) {
+	var _p_wkb unsafe.Pointer
+	if len(wkb) > 0 {
+		_p_wkb = unsafe.Pointer(&wkb[0])
+	}
+	_r0, _err := functions.RasterFromWKB(_p_wkb, uint(len(wkb)))
 	if _err != nil {
 		return nil, _err
 	}
@@ -42,17 +46,19 @@ func RasterFromHexWKB(hexwkb string) (unsafe.Pointer, error) {
 }
 
 // RasterAsWKB is MEOS raster_as_wkb.
-func RasterAsWKB(rast unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.RasterAsWKB(rast, variant, size_out)
+func RasterAsWKB(rast unsafe.Pointer, variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.RasterAsWKB(rast, variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // RasterAsHexWKB is MEOS raster_as_hexwkb.
-func RasterAsHexWKB(rast unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.RasterAsHexwkb(rast, variant, size_out)
+func RasterAsHexWKB(rast unsafe.Pointer, variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.RasterAsHexwkb(rast, variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -69,8 +75,12 @@ func RasterCopy(rast unsafe.Pointer) (unsafe.Pointer, error) {
 }
 
 // RasterMake is MEOS raster_make.
-func RasterMake(width int, height int, upperleftx float64, upperlefty float64, scalex float64, scaley float64, skewx float64, skewy float64, srid int32, pixeltype string, nodataval float64, has_nodata bool, pixels unsafe.Pointer, size uint) (unsafe.Pointer, error) {
-	_r0, _err := functions.RasterMake(width, height, upperleftx, upperlefty, scalex, scaley, skewx, skewy, srid, pixeltype, nodataval, has_nodata, pixels, size)
+func RasterMake(width int, height int, upperleftx float64, upperlefty float64, scalex float64, scaley float64, skewx float64, skewy float64, srid int32, pixeltype string, nodataval float64, has_nodata bool, pixels []byte) (unsafe.Pointer, error) {
+	var _p_pixels unsafe.Pointer
+	if len(pixels) > 0 {
+		_p_pixels = unsafe.Pointer(&pixels[0])
+	}
+	_r0, _err := functions.RasterMake(width, height, upperleftx, upperlefty, scalex, scaley, skewx, skewy, srid, pixeltype, nodataval, has_nodata, _p_pixels, uint(len(pixels)))
 	if _err != nil {
 		return nil, _err
 	}
@@ -234,12 +244,13 @@ func RasterBandNodataValue(rast unsafe.Pointer, band int) (float64, bool, error)
 }
 
 // RasterBandPixels is MEOS raster_band_pixels.
-func RasterBandPixels(rast unsafe.Pointer, band int, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.RasterBandPixels(rast, band, size_out)
+func RasterBandPixels(rast unsafe.Pointer, band int) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.RasterBandPixels(rast, band, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // RasterClip is MEOS raster_clip.
@@ -468,8 +479,12 @@ func RasterMinusValueGdal(traj *Temporal, path string, band int, vspan *Span) (*
 }
 
 // RasterTileValueQuadbin is MEOS raster_tile_value_quadbin.
-func RasterTileValueQuadbin(traj *Temporal, pixels unsafe.Pointer, pixels_size uint, width int32, height int32, quadbin uint64, pixtype functions.MeosPixType, nodata float64, has_nodata bool) (*Temporal, error) {
-	_r0, _err := functions.RasterTileValueQuadbin(functions.TemporalFromPointer(traj.Pointer()), pixels, pixels_size, width, height, quadbin, pixtype, nodata, has_nodata)
+func RasterTileValueQuadbin(traj *Temporal, pixels []byte, width int32, height int32, quadbin uint64, pixtype functions.MeosPixType, nodata float64, has_nodata bool) (*Temporal, error) {
+	var _p_pixels unsafe.Pointer
+	if len(pixels) > 0 {
+		_p_pixels = unsafe.Pointer(&pixels[0])
+	}
+	_r0, _err := functions.RasterTileValueQuadbin(functions.TemporalFromPointer(traj.Pointer()), _p_pixels, uint(len(pixels)), width, height, quadbin, pixtype, nodata, has_nodata)
 	if _err != nil {
 		return nil, _err
 	}
diff --git a/types/s2cellset.go b/types/s2cellset.go
index 3e0156d..1a65f92 100644
--- a/types/s2cellset.go
+++ b/types/s2cellset.go
@@ -117,8 +117,8 @@ func (x *S2CellSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) {
 }
 
 // S2CellSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb.
-func S2CellSetFromEWKB(wkb unsafe.Pointer, size uint) (*S2CellSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func S2CellSetFromEWKB(wkb []byte) (*S2CellSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -162,8 +162,8 @@ func S2CellSetFromText(str string) (*S2CellSet, error) {
 }
 
 // S2CellSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func S2CellSetFromWKB(wkb unsafe.Pointer, size uint) (*S2CellSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func S2CellSetFromWKB(wkb []byte) (*S2CellSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/set.go b/types/set.go
index 1500f3c..a6ac658 100644
--- a/types/set.go
+++ b/types/set.go
@@ -24,8 +24,9 @@ func SetFromPointer(p unsafe.Pointer) *Set {
 }
 
 // AsHexWKB is MEOS set_as_hexwkb.
-func (x *Set) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.SetAsHexwkb(functions.SetFromPointer(x.Pointer()), variant, size_out)
+func (x *Set) AsHexWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.SetAsHexwkb(functions.SetFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -33,12 +34,13 @@ func (x *Set) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
 }
 
 // AsWKB is MEOS set_as_wkb.
-func (x *Set) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.SetAsWKB(functions.SetFromPointer(x.Pointer()), variant, size_out)
+func (x *Set) AsWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.SetAsWKB(functions.SetFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // SetFromHexWKB is MEOS set_from_hexwkb.
@@ -51,8 +53,12 @@ func SetFromHexWKB(hexwkb string) (*Set, error) {
 }
 
 // SetFromWKB is MEOS set_from_wkb.
-func SetFromWKB(wkb unsafe.Pointer, size uint) (*Set, error) {
-	_r0, _err := functions.SetFromWKB(wkb, size)
+func SetFromWKB(wkb []byte) (*Set, error) {
+	var _p_wkb unsafe.Pointer
+	if len(wkb) > 0 {
+		_p_wkb = unsafe.Pointer(&wkb[0])
+	}
+	_r0, _err := functions.SetFromWKB(_p_wkb, uint(len(wkb)))
 	if _err != nil {
 		return nil, _err
 	}
@@ -195,12 +201,13 @@ func (x *Set) Ne(s2 *Set) (bool, error) {
 }
 
 // Sortkey is MEOS set_sortkey.
-func (x *Set) Sortkey(size unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.SetSortkey(functions.SetFromPointer(x.Pointer()), size)
+func (x *Set) Sortkey() ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.SetSortkey(functions.SetFromPointer(x.Pointer()), unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // Spans is MEOS set_spans.
diff --git a/types/span.go b/types/span.go
index 4d1131c..8c4967f 100644
--- a/types/span.go
+++ b/types/span.go
@@ -24,8 +24,9 @@ func SpanFromPointer(p unsafe.Pointer) *Span {
 }
 
 // AsHexWKB is MEOS span_as_hexwkb.
-func (x *Span) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.SpanAsHexwkb(functions.SpanFromPointer(x.Pointer()), variant, size_out)
+func (x *Span) AsHexWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.SpanAsHexwkb(functions.SpanFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -33,12 +34,13 @@ func (x *Span) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error)
 }
 
 // AsWKB is MEOS span_as_wkb.
-func (x *Span) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.SpanAsWKB(functions.SpanFromPointer(x.Pointer()), variant, size_out)
+func (x *Span) AsWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.SpanAsWKB(functions.SpanFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // SpanFromHexWKB is MEOS span_from_hexwkb.
@@ -51,8 +53,12 @@ func SpanFromHexWKB(hexwkb string) (*Span, error) {
 }
 
 // SpanFromWKB is MEOS span_from_wkb.
-func SpanFromWKB(wkb unsafe.Pointer, size uint) (*Span, error) {
-	_r0, _err := functions.SpanFromWKB(wkb, size)
+func SpanFromWKB(wkb []byte) (*Span, error) {
+	var _p_wkb unsafe.Pointer
+	if len(wkb) > 0 {
+		_p_wkb = unsafe.Pointer(&wkb[0])
+	}
+	_r0, _err := functions.SpanFromWKB(_p_wkb, uint(len(wkb)))
 	if _err != nil {
 		return nil, _err
 	}
@@ -177,12 +183,13 @@ func (x *Span) Ne(s2 *Span) (bool, error) {
 }
 
 // Sortkey is MEOS span_sortkey.
-func (x *Span) Sortkey(size unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.SpanSortkey(functions.SpanFromPointer(x.Pointer()), size)
+func (x *Span) Sortkey() ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.SpanSortkey(functions.SpanFromPointer(x.Pointer()), unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // ToTbox is MEOS span_to_tbox.
diff --git a/types/spanset.go b/types/spanset.go
index 4e9cbb0..2206c47 100644
--- a/types/spanset.go
+++ b/types/spanset.go
@@ -24,8 +24,9 @@ func SpanSetFromPointer(p unsafe.Pointer) *SpanSet {
 }
 
 // AsHexWKB is MEOS spanset_as_hexwkb.
-func (x *SpanSet) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.SpansetAsHexwkb(functions.SpanSetFromPointer(x.Pointer()), variant, size_out)
+func (x *SpanSet) AsHexWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.SpansetAsHexwkb(functions.SpanSetFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -33,12 +34,13 @@ func (x *SpanSet) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, erro
 }
 
 // AsWKB is MEOS spanset_as_wkb.
-func (x *SpanSet) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.SpansetAsWKB(functions.SpanSetFromPointer(x.Pointer()), variant, size_out)
+func (x *SpanSet) AsWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.SpansetAsWKB(functions.SpanSetFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // SpanSetFromHexWKB is MEOS spanset_from_hexwkb.
@@ -51,8 +53,12 @@ func SpanSetFromHexWKB(hexwkb string) (*SpanSet, error) {
 }
 
 // SpanSetFromWKB is MEOS spanset_from_wkb.
-func SpanSetFromWKB(wkb unsafe.Pointer, size uint) (*SpanSet, error) {
-	_r0, _err := functions.SpansetFromWKB(wkb, size)
+func SpanSetFromWKB(wkb []byte) (*SpanSet, error) {
+	var _p_wkb unsafe.Pointer
+	if len(wkb) > 0 {
+		_p_wkb = unsafe.Pointer(&wkb[0])
+	}
+	_r0, _err := functions.SpansetFromWKB(_p_wkb, uint(len(wkb)))
 	if _err != nil {
 		return nil, _err
 	}
@@ -240,12 +246,13 @@ func (x *SpanSet) Ne(ss2 *SpanSet) (bool, error) {
 }
 
 // Sortkey is MEOS spanset_sortkey.
-func (x *SpanSet) Sortkey(size unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.SpansetSortkey(functions.SpanSetFromPointer(x.Pointer()), size)
+func (x *SpanSet) Sortkey() ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.SpansetSortkey(functions.SpanSetFromPointer(x.Pointer()), unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // Spans is MEOS spanset_spans.
diff --git a/types/spatialset.go b/types/spatialset.go
index 3af4c9f..c6af562 100644
--- a/types/spatialset.go
+++ b/types/spatialset.go
@@ -42,12 +42,13 @@ func (x *SpatialSet) AsText(maxdd int) (string, error) {
 }
 
 // AsEWKB is MEOS spatialset_as_ewkb.
-func (x *SpatialSet) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.SpatialsetAsEWKB(functions.SetFromPointer(x.Pointer()), variant, size_out)
+func (x *SpatialSet) AsEWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.SpatialsetAsEWKB(functions.SetFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // AsEWKT is MEOS spatialset_as_ewkt.
@@ -60,8 +61,9 @@ func (x *SpatialSet) AsEWKT(maxdd int) (string, error) {
 }
 
 // AsHexEWKB is MEOS spatialset_as_hexewkb.
-func (x *SpatialSet) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.SpatialsetAsHexewkb(functions.SetFromPointer(x.Pointer()), variant, size_out)
+func (x *SpatialSet) AsHexEWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.SpatialsetAsHexewkb(functions.SetFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
diff --git a/types/stbox.go b/types/stbox.go
index fbbc4d7..7f47165 100644
--- a/types/stbox.go
+++ b/types/stbox.go
@@ -24,17 +24,19 @@ func STBoxFromPointer(p unsafe.Pointer) *STBox {
 }
 
 // AsEWKB is MEOS stbox_as_ewkb.
-func (x *STBox) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.STBOXAsEWKB(functions.STBoxFromPointer(x.Pointer()), variant, size_out)
+func (x *STBox) AsEWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.STBOXAsEWKB(functions.STBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // AsHexEWKB is MEOS stbox_as_hexewkb.
-func (x *STBox) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.STBOXAsHexewkb(functions.STBoxFromPointer(x.Pointer()), variant, size_out)
+func (x *STBox) AsHexEWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.STBOXAsHexewkb(functions.STBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -42,8 +44,9 @@ func (x *STBox) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error
 }
 
 // AsHexWKB is MEOS stbox_as_hexwkb.
-func (x *STBox) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.STBOXAsHexwkb(functions.STBoxFromPointer(x.Pointer()), variant, size_out)
+func (x *STBox) AsHexWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.STBOXAsHexwkb(functions.STBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -51,12 +54,13 @@ func (x *STBox) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error)
 }
 
 // AsWKB is MEOS stbox_as_wkb.
-func (x *STBox) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.STBOXAsWKB(functions.STBoxFromPointer(x.Pointer()), variant, size_out)
+func (x *STBox) AsWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.STBOXAsWKB(functions.STBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // STBoxFromHexWKB is MEOS stbox_from_hexwkb.
@@ -69,8 +73,12 @@ func STBoxFromHexWKB(hexwkb string) (*STBox, error) {
 }
 
 // STBoxFromWKB is MEOS stbox_from_wkb.
-func STBoxFromWKB(wkb unsafe.Pointer, size uint) (*STBox, error) {
-	_r0, _err := functions.STBOXFromWKB(wkb, size)
+func STBoxFromWKB(wkb []byte) (*STBox, error) {
+	var _p_wkb unsafe.Pointer
+	if len(wkb) > 0 {
+		_p_wkb = unsafe.Pointer(&wkb[0])
+	}
+	_r0, _err := functions.STBOXFromWKB(_p_wkb, uint(len(wkb)))
 	if _err != nil {
 		return nil, _err
 	}
@@ -468,12 +476,13 @@ func (x *STBox) Ne(box2 *STBox) (bool, error) {
 }
 
 // Sortkey is MEOS stbox_sortkey.
-func (x *STBox) Sortkey(size unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.STBOXSortkey(functions.STBoxFromPointer(x.Pointer()), size)
+func (x *STBox) Sortkey() ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.STBOXSortkey(functions.STBoxFromPointer(x.Pointer()), unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // SpatialDistance is MEOS stbox_spatial_distance.
@@ -504,8 +513,8 @@ func (x *STBox) SpaceTiles(xsize float64, ysize float64, zsize float64, sorigin
 }
 
 // STBoxFromEWKB is the portable fromEWKB of MEOS stbox_from_wkb.
-func STBoxFromEWKB(wkb unsafe.Pointer, size uint) (*STBox, error) {
-	return STBoxFromWKB(wkb, size)
+func STBoxFromEWKB(wkb []byte) (*STBox, error) {
+	return STBoxFromWKB(wkb)
 }
 
 // STBoxFromHexEWKB is the portable fromHexEWKB of MEOS stbox_from_hexwkb.
diff --git a/types/tbigint.go b/types/tbigint.go
index 2ca1fe1..b89bffd 100644
--- a/types/tbigint.go
+++ b/types/tbigint.go
@@ -287,8 +287,8 @@ func TBigintFromText(str string) (*TBigint, error) {
 }
 
 // TBigintFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TBigintFromWKB(wkb unsafe.Pointer, size uint) (*TBigint, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TBigintFromWKB(wkb []byte) (*TBigint, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tbool.go b/types/tbool.go
index ecb59fb..bcf07fd 100644
--- a/types/tbool.go
+++ b/types/tbool.go
@@ -188,8 +188,8 @@ func TBoolFromText(str string) (*TBool, error) {
 }
 
 // TBoolFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TBoolFromWKB(wkb unsafe.Pointer, size uint) (*TBool, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TBoolFromWKB(wkb []byte) (*TBool, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tbox.go b/types/tbox.go
index ae60a67..32634eb 100644
--- a/types/tbox.go
+++ b/types/tbox.go
@@ -24,8 +24,9 @@ func TBoxFromPointer(p unsafe.Pointer) *TBox {
 }
 
 // AsHexWKB is MEOS tbox_as_hexwkb.
-func (x *TBox) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.TBOXAsHexwkb(functions.TBoxFromPointer(x.Pointer()), variant, size_out)
+func (x *TBox) AsHexWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.TBOXAsHexwkb(functions.TBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -33,12 +34,13 @@ func (x *TBox) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error)
 }
 
 // AsWKB is MEOS tbox_as_wkb.
-func (x *TBox) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.TBOXAsWKB(functions.TBoxFromPointer(x.Pointer()), variant, size_out)
+func (x *TBox) AsWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.TBOXAsWKB(functions.TBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // TBoxFromHexWKB is MEOS tbox_from_hexwkb.
@@ -51,8 +53,12 @@ func TBoxFromHexWKB(hexwkb string) (*TBox, error) {
 }
 
 // TBoxFromWKB is MEOS tbox_from_wkb.
-func TBoxFromWKB(wkb unsafe.Pointer, size uint) (*TBox, error) {
-	_r0, _err := functions.TBOXFromWKB(wkb, size)
+func TBoxFromWKB(wkb []byte) (*TBox, error) {
+	var _p_wkb unsafe.Pointer
+	if len(wkb) > 0 {
+		_p_wkb = unsafe.Pointer(&wkb[0])
+	}
+	_r0, _err := functions.TBOXFromWKB(_p_wkb, uint(len(wkb)))
 	if _err != nil {
 		return nil, _err
 	}
@@ -336,12 +342,13 @@ func (x *TBox) Ne(box2 *TBox) (bool, error) {
 }
 
 // Sortkey is MEOS tbox_sortkey.
-func (x *TBox) Sortkey(size unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.TBOXSortkey(functions.TBoxFromPointer(x.Pointer()), size)
+func (x *TBox) Sortkey() ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.TBOXSortkey(functions.TBoxFromPointer(x.Pointer()), unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // TBoxGetValueTile is MEOS tbox_get_value_tile.
diff --git a/types/tcbuffer.go b/types/tcbuffer.go
index b863d37..bbf8b71 100644
--- a/types/tcbuffer.go
+++ b/types/tcbuffer.go
@@ -273,8 +273,8 @@ func (x *TCbuffer) MinusStbox(box *STBox, border_inc bool) (*Temporal, error) {
 }
 
 // TCbufferFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb.
-func TCbufferFromEWKB(wkb unsafe.Pointer, size uint) (*TCbuffer, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TCbufferFromEWKB(wkb []byte) (*TCbuffer, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -318,8 +318,8 @@ func TCbufferFromText(str string) (*TCbuffer, error) {
 }
 
 // TCbufferFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TCbufferFromWKB(wkb unsafe.Pointer, size uint) (*TCbuffer, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TCbufferFromWKB(wkb []byte) (*TCbuffer, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/temporal.go b/types/temporal.go
index ee6edd4..2ec7271 100644
--- a/types/temporal.go
+++ b/types/temporal.go
@@ -26,8 +26,9 @@ func TemporalFromPointer(p unsafe.Pointer) *Temporal {
 }
 
 // AsHexWKB is MEOS temporal_as_hexwkb.
-func (x *Temporal) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.TemporalAsHexwkb(functions.TemporalFromPointer(x.Pointer()), variant, size_out)
+func (x *Temporal) AsHexWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.TemporalAsHexwkb(functions.TemporalFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -44,12 +45,13 @@ func (x *Temporal) AsMFJSON(option int, flags int, precision int, srs *string) (
 }
 
 // AsWKB is MEOS temporal_as_wkb.
-func (x *Temporal) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.TemporalAsWKB(functions.TemporalFromPointer(x.Pointer()), variant, size_out)
+func (x *Temporal) AsWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.TemporalAsWKB(functions.TemporalFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // TemporalFromHexWKB is MEOS temporal_from_hexwkb.
@@ -62,8 +64,12 @@ func TemporalFromHexWKB(hexwkb string) (*Temporal, error) {
 }
 
 // TemporalFromWKB is MEOS temporal_from_wkb.
-func TemporalFromWKB(wkb unsafe.Pointer, size uint) (*Temporal, error) {
-	_r0, _err := functions.TemporalFromWKB(wkb, size)
+func TemporalFromWKB(wkb []byte) (*Temporal, error) {
+	var _p_wkb unsafe.Pointer
+	if len(wkb) > 0 {
+		_p_wkb = unsafe.Pointer(&wkb[0])
+	}
+	_r0, _err := functions.TemporalFromWKB(_p_wkb, uint(len(wkb)))
 	if _err != nil {
 		return nil, _err
 	}
@@ -677,12 +683,13 @@ func (x *Temporal) Ne(temp2 *Temporal) (bool, error) {
 }
 
 // Sortkey is MEOS temporal_sortkey.
-func (x *Temporal) Sortkey(size unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.TemporalSortkey(functions.TemporalFromPointer(x.Pointer()), size)
+func (x *Temporal) Sortkey() ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.TemporalSortkey(functions.TemporalFromPointer(x.Pointer()), unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // Spans is MEOS temporal_spans.
diff --git a/types/textset.go b/types/textset.go
index 042e837..e465689 100644
--- a/types/textset.go
+++ b/types/textset.go
@@ -149,8 +149,8 @@ func TextSetFromText(str string) (*TextSet, error) {
 }
 
 // TextSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func TextSetFromWKB(wkb unsafe.Pointer, size uint) (*TextSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func TextSetFromWKB(wkb []byte) (*TextSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tfloat.go b/types/tfloat.go
index 1e84faf..457e02e 100644
--- a/types/tfloat.go
+++ b/types/tfloat.go
@@ -350,8 +350,8 @@ func TFloatFromText(str string) (*TFloat, error) {
 }
 
 // TFloatFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TFloatFromWKB(wkb unsafe.Pointer, size uint) (*TFloat, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TFloatFromWKB(wkb []byte) (*TFloat, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tgeogpoint.go b/types/tgeogpoint.go
index c298824..e891eb6 100644
--- a/types/tgeogpoint.go
+++ b/types/tgeogpoint.go
@@ -123,8 +123,8 @@ func (x *TGeogPoint) S2cellSplit(level int32, border_inc bool, cells unsafe.Poin
 }
 
 // TGeogPointFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb.
-func TGeogPointFromEWKB(wkb unsafe.Pointer, size uint) (*TGeogPoint, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TGeogPointFromEWKB(wkb []byte) (*TGeogPoint, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -168,8 +168,8 @@ func TGeogPointFromText(str string) (*TGeogPoint, error) {
 }
 
 // TGeogPointFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TGeogPointFromWKB(wkb unsafe.Pointer, size uint) (*TGeogPoint, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TGeogPointFromWKB(wkb []byte) (*TGeogPoint, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tgeography.go b/types/tgeography.go
index 7ad9ae1..4a94467 100644
--- a/types/tgeography.go
+++ b/types/tgeography.go
@@ -60,8 +60,8 @@ func (x *TGeography) ToTgeometry() (*Temporal, error) {
 }
 
 // TGeographyFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb.
-func TGeographyFromEWKB(wkb unsafe.Pointer, size uint) (*TGeography, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TGeographyFromEWKB(wkb []byte) (*TGeography, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -105,8 +105,8 @@ func TGeographyFromText(str string) (*TGeography, error) {
 }
 
 // TGeographyFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TGeographyFromWKB(wkb unsafe.Pointer, size uint) (*TGeography, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TGeographyFromWKB(wkb []byte) (*TGeography, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tgeometry.go b/types/tgeometry.go
index 2f73cd2..a0af001 100644
--- a/types/tgeometry.go
+++ b/types/tgeometry.go
@@ -69,8 +69,8 @@ func (x *TGeometry) ToTcbuffer() (*Temporal, error) {
 }
 
 // TGeometryFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb.
-func TGeometryFromEWKB(wkb unsafe.Pointer, size uint) (*TGeometry, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TGeometryFromEWKB(wkb []byte) (*TGeometry, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -114,8 +114,8 @@ func TGeometryFromText(str string) (*TGeometry, error) {
 }
 
 // TGeometryFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TGeometryFromWKB(wkb unsafe.Pointer, size uint) (*TGeometry, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TGeometryFromWKB(wkb []byte) (*TGeometry, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tgeompoint.go b/types/tgeompoint.go
index 85dee70..ed72097 100644
--- a/types/tgeompoint.go
+++ b/types/tgeompoint.go
@@ -123,8 +123,8 @@ func (x *TGeomPoint) S2cellSplit(level int32, border_inc bool, cells unsafe.Poin
 }
 
 // TGeomPointFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb.
-func TGeomPointFromEWKB(wkb unsafe.Pointer, size uint) (*TGeomPoint, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TGeomPointFromEWKB(wkb []byte) (*TGeomPoint, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -168,8 +168,8 @@ func TGeomPointFromText(str string) (*TGeomPoint, error) {
 }
 
 // TGeomPointFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TGeomPointFromWKB(wkb unsafe.Pointer, size uint) (*TGeomPoint, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TGeomPointFromWKB(wkb []byte) (*TGeomPoint, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/th3index.go b/types/th3index.go
index 39a07e5..1f7706c 100644
--- a/types/th3index.go
+++ b/types/th3index.go
@@ -372,8 +372,8 @@ func (x *TH3Index) EdgeLength() (*Temporal, error) {
 }
 
 // TH3IndexFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb.
-func TH3IndexFromEWKB(wkb unsafe.Pointer, size uint) (*TH3Index, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TH3IndexFromEWKB(wkb []byte) (*TH3Index, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -417,8 +417,8 @@ func TH3IndexFromText(str string) (*TH3Index, error) {
 }
 
 // TH3IndexFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TH3IndexFromWKB(wkb unsafe.Pointer, size uint) (*TH3Index, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TH3IndexFromWKB(wkb []byte) (*TH3Index, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tint.go b/types/tint.go
index d6a4f33..d1fcf83 100644
--- a/types/tint.go
+++ b/types/tint.go
@@ -260,8 +260,8 @@ func TIntFromText(str string) (*TInt, error) {
 }
 
 // TIntFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TIntFromWKB(wkb unsafe.Pointer, size uint) (*TInt, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TIntFromWKB(wkb []byte) (*TInt, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tjsonb.go b/types/tjsonb.go
index 8e7e64b..0a39cd7 100644
--- a/types/tjsonb.go
+++ b/types/tjsonb.go
@@ -467,8 +467,8 @@ func TJsonbFromText(str string) (*TJsonb, error) {
 }
 
 // TJsonbFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TJsonbFromWKB(wkb unsafe.Pointer, size uint) (*TJsonb, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TJsonbFromWKB(wkb []byte) (*TJsonb, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tnpoint.go b/types/tnpoint.go
index ea46fb3..11039b7 100644
--- a/types/tnpoint.go
+++ b/types/tnpoint.go
@@ -282,8 +282,8 @@ func (x *TNpoint) MinusStbox(box *STBox, border_inc bool) (*Temporal, error) {
 }
 
 // TNpointFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb.
-func TNpointFromEWKB(wkb unsafe.Pointer, size uint) (*TNpoint, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TNpointFromEWKB(wkb []byte) (*TNpoint, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -327,8 +327,8 @@ func TNpointFromText(str string) (*TNpoint, error) {
 }
 
 // TNpointFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TNpointFromWKB(wkb unsafe.Pointer, size uint) (*TNpoint, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TNpointFromWKB(wkb []byte) (*TNpoint, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tpcbox.go b/types/tpcbox.go
index d394a26..01737d1 100644
--- a/types/tpcbox.go
+++ b/types/tpcbox.go
@@ -24,17 +24,19 @@ func TPCBoxFromPointer(p unsafe.Pointer) *TPCBox {
 }
 
 // AsEWKB is MEOS tpcbox_as_ewkb.
-func (x *TPCBox) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.TpcboxAsEWKB(functions.TPCBoxFromPointer(x.Pointer()), variant, size_out)
+func (x *TPCBox) AsEWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.TpcboxAsEWKB(functions.TPCBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // AsHexEWKB is MEOS tpcbox_as_hexewkb.
-func (x *TPCBox) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.TpcboxAsHexewkb(functions.TPCBoxFromPointer(x.Pointer()), variant, size_out)
+func (x *TPCBox) AsHexEWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.TpcboxAsHexewkb(functions.TPCBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -42,8 +44,9 @@ func (x *TPCBox) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, erro
 }
 
 // AsHexWKB is MEOS tpcbox_as_hexwkb.
-func (x *TPCBox) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.TpcboxAsHexwkb(functions.TPCBoxFromPointer(x.Pointer()), variant, size_out)
+func (x *TPCBox) AsHexWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.TpcboxAsHexwkb(functions.TPCBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
@@ -51,12 +54,13 @@ func (x *TPCBox) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error
 }
 
 // AsWKB is MEOS tpcbox_as_wkb.
-func (x *TPCBox) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.TpcboxAsWKB(functions.TPCBoxFromPointer(x.Pointer()), variant, size_out)
+func (x *TPCBox) AsWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.TpcboxAsWKB(functions.TPCBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // TPCBoxFromHexWKB is MEOS tpcbox_from_hexwkb.
@@ -69,8 +73,12 @@ func TPCBoxFromHexWKB(hexwkb string) (*TPCBox, error) {
 }
 
 // TPCBoxFromWKB is MEOS tpcbox_from_wkb.
-func TPCBoxFromWKB(wkb unsafe.Pointer, size uint) (*TPCBox, error) {
-	_r0, _err := functions.TpcboxFromWKB(wkb, size)
+func TPCBoxFromWKB(wkb []byte) (*TPCBox, error) {
+	var _p_wkb unsafe.Pointer
+	if len(wkb) > 0 {
+		_p_wkb = unsafe.Pointer(&wkb[0])
+	}
+	_r0, _err := functions.TpcboxFromWKB(_p_wkb, uint(len(wkb)))
 	if _err != nil {
 		return nil, _err
 	}
@@ -342,12 +350,13 @@ func (x *TPCBox) Ne(box2 *TPCBox) (bool, error) {
 }
 
 // Sortkey is MEOS tpcbox_sortkey.
-func (x *TPCBox) Sortkey(size unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.TpcboxSortkey(functions.TPCBoxFromPointer(x.Pointer()), size)
+func (x *TPCBox) Sortkey() ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.TpcboxSortkey(functions.TPCBoxFromPointer(x.Pointer()), unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // Lt is MEOS tpcbox_lt.
@@ -387,8 +396,8 @@ func (x *TPCBox) Ge(box2 *TPCBox) (bool, error) {
 }
 
 // TPCBoxFromEWKB is the portable fromEWKB of MEOS tpcbox_from_wkb.
-func TPCBoxFromEWKB(wkb unsafe.Pointer, size uint) (*TPCBox, error) {
-	return TPCBoxFromWKB(wkb, size)
+func TPCBoxFromEWKB(wkb []byte) (*TPCBox, error) {
+	return TPCBoxFromWKB(wkb)
 }
 
 // TPCBoxFromHexEWKB is the portable fromHexEWKB of MEOS tpcbox_from_hexwkb.
diff --git a/types/tpcpatch.go b/types/tpcpatch.go
index 172d1e6..bfe4a5c 100644
--- a/types/tpcpatch.go
+++ b/types/tpcpatch.go
@@ -192,8 +192,8 @@ func (x *TPcpatch) Npoints() (int64, error) {
 }
 
 // TPcpatchFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb.
-func TPcpatchFromEWKB(wkb unsafe.Pointer, size uint) (*TPcpatch, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TPcpatchFromEWKB(wkb []byte) (*TPcpatch, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -237,8 +237,8 @@ func TPcpatchFromText(str string) (*TPcpatch, error) {
 }
 
 // TPcpatchFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TPcpatchFromWKB(wkb unsafe.Pointer, size uint) (*TPcpatch, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TPcpatchFromWKB(wkb []byte) (*TPcpatch, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tpcpoint.go b/types/tpcpoint.go
index 0a277ad..d1a8c49 100644
--- a/types/tpcpoint.go
+++ b/types/tpcpoint.go
@@ -165,8 +165,8 @@ func (x *TPcpoint) Pcid() (uint32, error) {
 }
 
 // TPcpointFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb.
-func TPcpointFromEWKB(wkb unsafe.Pointer, size uint) (*TPcpoint, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TPcpointFromEWKB(wkb []byte) (*TPcpoint, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -210,8 +210,8 @@ func TPcpointFromText(str string) (*TPcpoint, error) {
 }
 
 // TPcpointFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TPcpointFromWKB(wkb unsafe.Pointer, size uint) (*TPcpoint, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TPcpointFromWKB(wkb []byte) (*TPcpoint, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tpose.go b/types/tpose.go
index dafd85e..8ded44a 100644
--- a/types/tpose.go
+++ b/types/tpose.go
@@ -399,8 +399,8 @@ func (x *TPose) MinusStbox(box *STBox, border_inc bool) (*Temporal, error) {
 }
 
 // TPoseFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb.
-func TPoseFromEWKB(wkb unsafe.Pointer, size uint) (*TPose, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TPoseFromEWKB(wkb []byte) (*TPose, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -444,8 +444,8 @@ func TPoseFromText(str string) (*TPose, error) {
 }
 
 // TPoseFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TPoseFromWKB(wkb unsafe.Pointer, size uint) (*TPose, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TPoseFromWKB(wkb []byte) (*TPose, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tposechain.go b/types/tposechain.go
index ac761e0..5d265c0 100644
--- a/types/tposechain.go
+++ b/types/tposechain.go
@@ -195,8 +195,8 @@ func (x *TPoseChain) MinusValue(pc unsafe.Pointer) (*Temporal, error) {
 }
 
 // TPoseChainFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb.
-func TPoseChainFromEWKB(wkb unsafe.Pointer, size uint) (*TPoseChain, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TPoseChainFromEWKB(wkb []byte) (*TPoseChain, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -240,8 +240,8 @@ func TPoseChainFromText(str string) (*TPoseChain, error) {
 }
 
 // TPoseChainFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TPoseChainFromWKB(wkb unsafe.Pointer, size uint) (*TPoseChain, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TPoseChainFromWKB(wkb []byte) (*TPoseChain, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tquadbin.go b/types/tquadbin.go
index d4dc288..6698692 100644
--- a/types/tquadbin.go
+++ b/types/tquadbin.go
@@ -183,8 +183,8 @@ func (x *TQuadbin) GridDistance(dest *Temporal) (*Temporal, error) {
 }
 
 // TQuadbinFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb.
-func TQuadbinFromEWKB(wkb unsafe.Pointer, size uint) (*TQuadbin, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TQuadbinFromEWKB(wkb []byte) (*TQuadbin, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -228,8 +228,8 @@ func TQuadbinFromText(str string) (*TQuadbin, error) {
 }
 
 // TQuadbinFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TQuadbinFromWKB(wkb unsafe.Pointer, size uint) (*TQuadbin, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TQuadbinFromWKB(wkb []byte) (*TQuadbin, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/trgeometry.go b/types/trgeometry.go
index 71d5a0c..cabe565 100644
--- a/types/trgeometry.go
+++ b/types/trgeometry.go
@@ -723,8 +723,8 @@ func (x *TRGeometry) MinusTstzspanset(ss *SpanSet) (*Temporal, error) {
 }
 
 // TRGeometryFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb.
-func TRGeometryFromEWKB(wkb unsafe.Pointer, size uint) (*TRGeometry, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TRGeometryFromEWKB(wkb []byte) (*TRGeometry, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -768,8 +768,8 @@ func TRGeometryFromText(str string) (*TRGeometry, error) {
 }
 
 // TRGeometryFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TRGeometryFromWKB(wkb unsafe.Pointer, size uint) (*TRGeometry, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TRGeometryFromWKB(wkb []byte) (*TRGeometry, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/ts2cell.go b/types/ts2cell.go
index 10281a8..263cd5f 100644
--- a/types/ts2cell.go
+++ b/types/ts2cell.go
@@ -183,8 +183,8 @@ func (x *TS2Cell) GridDistance(dest *Temporal) (*Temporal, error) {
 }
 
 // TS2CellFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb.
-func TS2CellFromEWKB(wkb unsafe.Pointer, size uint) (*TS2Cell, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TS2CellFromEWKB(wkb []byte) (*TS2Cell, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
@@ -228,8 +228,8 @@ func TS2CellFromText(str string) (*TS2Cell, error) {
 }
 
 // TS2CellFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TS2CellFromWKB(wkb unsafe.Pointer, size uint) (*TS2Cell, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TS2CellFromWKB(wkb []byte) (*TS2Cell, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tspatial.go b/types/tspatial.go
index ef73cbf..248a879 100644
--- a/types/tspatial.go
+++ b/types/tspatial.go
@@ -35,12 +35,13 @@ func (x *TSpatial) Out(maxdd int) (string, error) {
 }
 
 // AsEWKB is MEOS tspatial_as_ewkb.
-func (x *TSpatial) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) {
-	_r0, _err := functions.TspatialAsEWKB(functions.TemporalFromPointer(x.Pointer()), variant, size_out)
+func (x *TSpatial) AsEWKB(variant uint8) ([]byte, error) {
+	var _size uint64
+	_r0, _err := functions.TspatialAsEWKB(functions.TemporalFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return nil, _err
 	}
-	return _r0, nil
+	return functions.TakeBytes(_r0, _size), nil
 }
 
 // AsEWKT is MEOS tspatial_as_ewkt.
@@ -53,8 +54,9 @@ func (x *TSpatial) AsEWKT(maxdd int) (string, error) {
 }
 
 // AsHexEWKB is MEOS tspatial_as_hexewkb.
-func (x *TSpatial) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) {
-	_r0, _err := functions.TspatialAsHexewkb(functions.TemporalFromPointer(x.Pointer()), variant, size_out)
+func (x *TSpatial) AsHexEWKB(variant uint8) (string, error) {
+	var _size uint64
+	_r0, _err := functions.TspatialAsHexewkb(functions.TemporalFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size))
 	if _err != nil {
 		return "", _err
 	}
diff --git a/types/tstzset.go b/types/tstzset.go
index 60830d7..3ff3bd2 100644
--- a/types/tstzset.go
+++ b/types/tstzset.go
@@ -131,8 +131,8 @@ func TsTzSetFromText(str string) (*TsTzSet, error) {
 }
 
 // TsTzSetFromWKB is the portable fromWKB of MEOS set_from_wkb.
-func TsTzSetFromWKB(wkb unsafe.Pointer, size uint) (*TsTzSet, error) {
-	r, err := SetFromWKB(wkb, size)
+func TsTzSetFromWKB(wkb []byte) (*TsTzSet, error) {
+	r, err := SetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tstzspan.go b/types/tstzspan.go
index d870bba..4631ca1 100644
--- a/types/tstzspan.go
+++ b/types/tstzspan.go
@@ -110,8 +110,8 @@ func TsTzSpanFromText(str string) (*TsTzSpan, error) {
 }
 
 // TsTzSpanFromWKB is the portable fromWKB of MEOS span_from_wkb.
-func TsTzSpanFromWKB(wkb unsafe.Pointer, size uint) (*TsTzSpan, error) {
-	r, err := SpanFromWKB(wkb, size)
+func TsTzSpanFromWKB(wkb []byte) (*TsTzSpan, error) {
+	r, err := SpanFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/tstzspanset.go b/types/tstzspanset.go
index 5bffeae..575912a 100644
--- a/types/tstzspanset.go
+++ b/types/tstzspanset.go
@@ -149,8 +149,8 @@ func TsTzSpanSetFromText(str string) (*TsTzSpanSet, error) {
 }
 
 // TsTzSpanSetFromWKB is the portable fromWKB of MEOS spanset_from_wkb.
-func TsTzSpanSetFromWKB(wkb unsafe.Pointer, size uint) (*TsTzSpanSet, error) {
-	r, err := SpanSetFromWKB(wkb, size)
+func TsTzSpanSetFromWKB(wkb []byte) (*TsTzSpanSet, error) {
+	r, err := SpanSetFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}
diff --git a/types/ttext.go b/types/ttext.go
index 2a81515..3b0b659 100644
--- a/types/ttext.go
+++ b/types/ttext.go
@@ -224,8 +224,8 @@ func TTextFromText(str string) (*TText, error) {
 }
 
 // TTextFromWKB is the portable fromWKB of MEOS temporal_from_wkb.
-func TTextFromWKB(wkb unsafe.Pointer, size uint) (*TText, error) {
-	r, err := TemporalFromWKB(wkb, size)
+func TTextFromWKB(wkb []byte) (*TText, error) {
+	r, err := TemporalFromWKB(wkb)
 	if err != nil || r == nil {
 		return nil, err
 	}