@gtkx/ffi 0.10.4 → 0.11.0

package/dist/generated/graphene/matrix.js

@@ -11,25 +11,17 @@ import { registerNativeClass } from "../../registry.js";
 export class Matrix extends NativeObject {
     static glibTypeName = "GrapheneMatrix";
     static objectType = "boxed";
-    /**
-     * Allocates a new #graphene_matrix_t.
-     */
+    /** Allocates a new #graphene_matrix_t. */
     constructor() {
         super();
-        this.id = this.createPtr([]);
-    }
-    createPtr(_args) {
-        return call("libgraphene-1.0.so.0", "graphene_matrix_alloc", [], {
+        this.id = call("libgraphene-1.0.so.0", "graphene_matrix_alloc", [], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GrapheneMatrix",
+            lib: "libgraphene-1.0.so.0",
+            getTypeFn: "graphene_matrix_get_type",
         });
     }
-    static fromPtr(ptr) {
-        const instance = Object.create(Matrix.prototype);
-        instance.id = ptr;
-        return instance;
-    }
     /**
      * Decomposes a transformation matrix into its component transformations.
      *
@@ -38,18 +30,13 @@ export class Matrix extends NativeObject {
      * specifically, the decomposition code is based on the equivalent code
      * published in "Graphics Gems II", edited by Jim Arvo, and
      * [available online](http://web.archive.org/web/20150512160205/http://tog.acm.org/resources/GraphicsGems/gemsii/unmatrix.c).
-     * @param translate - the translation vector
-     * @param scale - the scale vector
-     * @param rotate - the rotation quaternion
-     * @param shear - the shear vector
-     * @param perspective - the perspective vector
      */
     decompose(translate, scale, rotate, shear, perspective) {
         return call("libgraphene-1.0.so.0", "graphene_matrix_decompose", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -58,81 +45,81 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec3",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec3_get_type",
                 },
-                value: translate?.id ?? translate,
+                value: translate.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec3",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec3_get_type",
                 },
-                value: scale?.id ?? scale,
+                value: scale.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneQuaternion",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_quaternion_get_type",
                 },
-                value: rotate?.id ?? rotate,
+                value: rotate.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec3",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec3_get_type",
                 },
-                value: shear?.id ?? shear,
+                value: shear.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec4",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec4_get_type",
                 },
-                value: perspective?.id ?? perspective,
+                value: perspective.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Computes the determinant of the given matrix.
-     */
+    /** Computes the determinant of the given matrix. */
     determinant() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_determinant", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
-        ], { type: "float", size: 32 });
+        ], {
+            type: "float",
+            size: 32,
+        });
     }
-    /**
-     * Checks whether the two given #graphene_matrix_t matrices are equal.
-     * @param b - a #graphene_matrix_t
-     */
+    /** Checks whether the two given #graphene_matrix_t matrices are equal. */
     equal(b) {
         return call("libgraphene-1.0.so.0", "graphene_matrix_equal", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -141,14 +128,16 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_matrix_get_type",
                 },
-                value: b?.id ?? b,
+                value: b.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Checks whether the two given #graphene_matrix_t matrices are
@@ -160,28 +149,27 @@ export class Matrix extends NativeObject {
      * graphene_matrix_near(). For instance:
      *
      * |[<!-- language="C" -->
-     * if (graphene_matrix_equal_fast (a, b))
-     * {
-     * // matrices are definitely the same
-     * }
-     * else
-     * {
-     * if (graphene_matrix_equal (a, b))
-     * // matrices contain the same values within an epsilon of FLT_EPSILON
-     * else if (graphene_matrix_near (a, b, 0.0001))
-     * // matrices contain the same values within an epsilon of 0.0001
-     * else
-     * // matrices are not equal
-     * }
+     *   if (graphene_matrix_equal_fast (a, b))
+     *     {
+     *       // matrices are definitely the same
+     *     }
+     *   else
+     *     {
+     *       if (graphene_matrix_equal (a, b))
+     *         // matrices contain the same values within an epsilon of FLT_EPSILON
+     *       else if (graphene_matrix_near (a, b, 0.0001))
+     *         // matrices contain the same values within an epsilon of 0.0001
+     *       else
+     *         // matrices are not equal
+     *     }
      * ]|
-     * @param b - a #graphene_matrix_t
      */
     equalFast(b) {
         return call("libgraphene-1.0.so.0", "graphene_matrix_equal_fast", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -190,184 +178,201 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_matrix_get_type",
                 },
-                value: b?.id ?? b,
+                value: b.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Frees the resources allocated by graphene_matrix_alloc().
-     */
+    /** Frees the resources allocated by graphene_matrix_alloc(). */
     free() {
         call("libgraphene-1.0.so.0", "graphene_matrix_free", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Retrieves the given row vector at `index_` inside a matrix.
-     * @param index_ - the index of the row vector, between 0 and 3
-     * @param res - return location for the #graphene_vec4_t
-     */
+    /** Retrieves the given row vector at `index_` inside a matrix. */
     getRow(index_, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_get_row", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: index_,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec4",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec4_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Retrieves the value at the given `row` and `col` index.
-     * @param row - the row index
-     * @param col - the column index
-     */
+    /** Retrieves the value at the given `row` and `col` index. */
     getValue(row, col) {
         return call("libgraphene-1.0.so.0", "graphene_matrix_get_value", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: row,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: col,
             },
-        ], { type: "float", size: 32 });
+        ], {
+            type: "float",
+            size: 32,
+        });
     }
-    /**
-     * Retrieves the scaling factor on the X axis in `m`.
-     */
+    /** Retrieves the scaling factor on the X axis in `m`. */
     getXScale() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_get_x_scale", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
-        ], { type: "float", size: 32 });
+        ], {
+            type: "float",
+            size: 32,
+        });
     }
-    /**
-     * Retrieves the translation component on the X axis from `m`.
-     */
+    /** Retrieves the translation component on the X axis from `m`. */
     getXTranslation() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_get_x_translation", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
-        ], { type: "float", size: 32 });
+        ], {
+            type: "float",
+            size: 32,
+        });
     }
-    /**
-     * Retrieves the scaling factor on the Y axis in `m`.
-     */
+    /** Retrieves the scaling factor on the Y axis in `m`. */
     getYScale() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_get_y_scale", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
-        ], { type: "float", size: 32 });
+        ], {
+            type: "float",
+            size: 32,
+        });
     }
-    /**
-     * Retrieves the translation component on the Y axis from `m`.
-     */
+    /** Retrieves the translation component on the Y axis from `m`. */
     getYTranslation() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_get_y_translation", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
-        ], { type: "float", size: 32 });
+        ], {
+            type: "float",
+            size: 32,
+        });
     }
-    /**
-     * Retrieves the scaling factor on the Z axis in `m`.
-     */
+    /** Retrieves the scaling factor on the Z axis in `m`. */
     getZScale() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_get_z_scale", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
-        ], { type: "float", size: 32 });
+        ], {
+            type: "float",
+            size: 32,
+        });
     }
-    /**
-     * Retrieves the translation component on the Z axis from `m`.
-     */
+    /** Retrieves the translation component on the Z axis from `m`. */
     getZTranslation() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_get_z_translation", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
-        ], { type: "float", size: 32 });
+        ], {
+            type: "float",
+            size: 32,
+        });
     }
     /**
      * Initializes a #graphene_matrix_t from the values of an affine
@@ -376,58 +381,70 @@ export class Matrix extends NativeObject {
      * The arguments map to the following matrix layout:
      *
      * |[<!-- language="plain" -->
-     * ⎛ xx  yx ⎞   ⎛  a   b  0 ⎞
-     * ⎜ xy  yy ⎟ = ⎜  c   d  0 ⎟
-     * ⎝ x0  y0 ⎠   ⎝ tx  ty  1 ⎠
+     *   ⎛ xx  yx ⎞   ⎛  a   b  0 ⎞
+     *   ⎜ xy  yy ⎟ = ⎜  c   d  0 ⎟
+     *   ⎝ x0  y0 ⎠   ⎝ tx  ty  1 ⎠
      * ]|
      *
      * This function can be used to convert between an affine matrix type
      * from other libraries and a #graphene_matrix_t.
-     * @param xx - the xx member
-     * @param yx - the yx member
-     * @param xy - the xy member
-     * @param yy - the yy member
-     * @param x_0 - the x0 member
-     * @param y_0 - the y0 member
      */
     initFrom_2d(xx, yx, xy, yy, x_0, y_0) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_from_2d", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: xx,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: yx,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: xy,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: yy,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: x_0,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: y_0,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GrapheneMatrix",
             lib: "libgraphene-1.0.so.0",
             getTypeFn: "graphene_matrix_get_type",
@@ -437,26 +454,33 @@ export class Matrix extends NativeObject {
     /**
      * Initializes a #graphene_matrix_t with the given array of floating
      * point values.
-     * @param v - an array of at least 16 floating
      */
     initFromFloat(v) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_from_float", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "array", itemType: { type: "float", size: 32 } },
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "float",
+                        size: 32,
+                    },
+                    listType: "array",
+                    ownership: "none",
+                },
                 value: v,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GrapheneMatrix",
             lib: "libgraphene-1.0.so.0",
             getTypeFn: "graphene_matrix_get_type",
@@ -466,14 +490,13 @@ export class Matrix extends NativeObject {
     /**
      * Initializes a #graphene_matrix_t using the values of the
      * given matrix.
-     * @param src - a #graphene_matrix_t
      */
     initFromMatrix(src) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_from_matrix", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -482,16 +505,16 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_matrix_get_type",
                 },
-                value: src?.id ?? src,
+                value: src.id,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GrapheneMatrix",
             lib: "libgraphene-1.0.so.0",
             getTypeFn: "graphene_matrix_get_type",
@@ -501,17 +524,13 @@ export class Matrix extends NativeObject {
     /**
      * Initializes a #graphene_matrix_t with the given four row
      * vectors.
-     * @param v0 - the first row vector
-     * @param v1 - the second row vector
-     * @param v2 - the third row vector
-     * @param v3 - the fourth row vector
      */
     initFromVec4(v0, v1, v2, v3) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_from_vec4", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -520,46 +539,46 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec4",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec4_get_type",
                 },
-                value: v0?.id ?? v0,
+                value: v0.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec4",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec4_get_type",
                 },
-                value: v1?.id ?? v1,
+                value: v1.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec4",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec4_get_type",
                 },
-                value: v2?.id ?? v2,
+                value: v2.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec4",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec4_get_type",
                 },
-                value: v3?.id ?? v3,
+                value: v3.id,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GrapheneMatrix",
             lib: "libgraphene-1.0.so.0",
             getTypeFn: "graphene_matrix_get_type",
@@ -570,66 +589,76 @@ export class Matrix extends NativeObject {
      * Initializes a #graphene_matrix_t compatible with #graphene_frustum_t.
      *
      * See also: graphene_frustum_init_from_matrix()
-     * @param left - distance of the left clipping plane
-     * @param right - distance of the right clipping plane
-     * @param bottom - distance of the bottom clipping plane
-     * @param top - distance of the top clipping plane
-     * @param zNear - distance of the near clipping plane
-     * @param zFar - distance of the far clipping plane
      */
     initFrustum(left, right, bottom, top, zNear, zFar) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_frustum", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: left,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: right,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: bottom,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: top,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: zNear,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: zFar,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GrapheneMatrix",
             lib: "libgraphene-1.0.so.0",
             getTypeFn: "graphene_matrix_get_type",
         });
         return getNativeObject(ptr, Matrix);
     }
-    /**
-     * Initializes a #graphene_matrix_t with the identity matrix.
-     */
+    /** Initializes a #graphene_matrix_t with the identity matrix. */
     initIdentity() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_identity", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -637,7 +666,7 @@ export class Matrix extends NativeObject {
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GrapheneMatrix",
             lib: "libgraphene-1.0.so.0",
             getTypeFn: "graphene_matrix_get_type",
@@ -661,16 +690,13 @@ export class Matrix extends NativeObject {
      * coordinates of the camera. Typically you would then apply the
      * camera projection transform to get from view to screen
      * coordinates.
-     * @param eye - the vector describing the position to look from
-     * @param center - the vector describing the position to look at
-     * @param up - the vector describing the world's upward direction; usually,
      */
     initLookAt(eye, center, up) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_look_at", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -679,132 +705,148 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec3",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec3_get_type",
                 },
-                value: eye?.id ?? eye,
+                value: eye.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec3",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec3_get_type",
                 },
-                value: center?.id ?? center,
+                value: center.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec3",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec3_get_type",
                 },
-                value: up?.id ?? up,
+                value: up.id,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GrapheneMatrix",
             lib: "libgraphene-1.0.so.0",
             getTypeFn: "graphene_matrix_get_type",
         });
         return getNativeObject(ptr, Matrix);
     }
-    /**
-     * Initializes a #graphene_matrix_t with an orthographic projection.
-     * @param left - the left edge of the clipping plane
-     * @param right - the right edge of the clipping plane
-     * @param top - the top edge of the clipping plane
-     * @param bottom - the bottom edge of the clipping plane
-     * @param zNear - the distance of the near clipping plane
-     * @param zFar - the distance of the far clipping plane
-     */
+    /** Initializes a #graphene_matrix_t with an orthographic projection. */
     initOrtho(left, right, top, bottom, zNear, zFar) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_ortho", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: left,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: right,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: top,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: bottom,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: zNear,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: zFar,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GrapheneMatrix",
             lib: "libgraphene-1.0.so.0",
             getTypeFn: "graphene_matrix_get_type",
         });
         return getNativeObject(ptr, Matrix);
     }
-    /**
-     * Initializes a #graphene_matrix_t with a perspective projection.
-     * @param fovy - the field of view angle, in degrees
-     * @param aspect - the aspect value
-     * @param zNear - the near Z plane
-     * @param zFar - the far Z plane
-     */
+    /** Initializes a #graphene_matrix_t with a perspective projection. */
     initPerspective(fovy, aspect, zNear, zFar) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_perspective", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: fovy,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: aspect,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: zNear,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: zFar,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GrapheneMatrix",
             lib: "libgraphene-1.0.so.0",
             getTypeFn: "graphene_matrix_get_type",
@@ -814,75 +856,80 @@ export class Matrix extends NativeObject {
     /**
      * Initializes `m` to represent a rotation of `angle` degrees on
      * the axis represented by the `axis` vector.
-     * @param angle - the rotation angle, in degrees
-     * @param axis - the axis vector as a #graphene_vec3_t
      */
     initRotate(angle, axis) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_rotate", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: angle,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec3",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec3_get_type",
                 },
-                value: axis?.id ?? axis,
+                value: axis.id,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GrapheneMatrix",
             lib: "libgraphene-1.0.so.0",
             getTypeFn: "graphene_matrix_get_type",
         });
         return getNativeObject(ptr, Matrix);
     }
-    /**
-     * Initializes a #graphene_matrix_t with the given scaling factors.
-     * @param x - the scale factor on the X axis
-     * @param y - the scale factor on the Y axis
-     * @param z - the scale factor on the Z axis
-     */
+    /** Initializes a #graphene_matrix_t with the given scaling factors. */
     initScale(x, y, z) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_scale", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: x,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: y,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: z,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GrapheneMatrix",
             lib: "libgraphene-1.0.so.0",
             getTypeFn: "graphene_matrix_get_type",
@@ -892,31 +939,35 @@ export class Matrix extends NativeObject {
     /**
      * Initializes a #graphene_matrix_t with a skew transformation
      * with the given factors.
-     * @param xSkew - skew factor, in radians, on the X axis
-     * @param ySkew - skew factor, in radians, on the Y axis
      */
     initSkew(xSkew, ySkew) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_skew", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: xSkew,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: ySkew,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GrapheneMatrix",
             lib: "libgraphene-1.0.so.0",
             getTypeFn: "graphene_matrix_get_type",
@@ -926,14 +977,13 @@ export class Matrix extends NativeObject {
     /**
      * Initializes a #graphene_matrix_t with a translation to the
      * given coordinates.
-     * @param p - the translation coordinates
      */
     initTranslate(p) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_translate", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -942,16 +992,16 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint3D",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point3d_get_type",
                 },
-                value: p?.id ?? p,
+                value: p.id,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GrapheneMatrix",
             lib: "libgraphene-1.0.so.0",
             getTypeFn: "graphene_matrix_get_type",
@@ -965,16 +1015,13 @@ export class Matrix extends NativeObject {
      * If either matrix cannot be reduced to their transformations
      * then the interpolation cannot be performed, and this function
      * will return an identity matrix.
-     * @param b - a #graphene_matrix_t
-     * @param factor - the linear interpolation factor
-     * @param res - return location for the
      */
     interpolate(b, factor, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_interpolate", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -983,39 +1030,41 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_matrix_get_type",
                 },
-                value: b?.id ?? b,
+                value: b.id,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: factor,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_matrix_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Inverts the given matrix.
-     * @param res - return location for the
-     */
+    /** Inverts the given matrix. */
     inverse(res) {
         return call("libgraphene-1.0.so.0", "graphene_matrix_inverse", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1024,14 +1073,16 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_matrix_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Checks whether the given #graphene_matrix_t is compatible with an
@@ -1042,76 +1093,76 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Checks whether a #graphene_matrix_t has a visible back face.
-     */
+    /** Checks whether a #graphene_matrix_t has a visible back face. */
     isBackfaceVisible() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_is_backface_visible", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Checks whether the given #graphene_matrix_t is the identity matrix.
-     */
+    /** Checks whether the given #graphene_matrix_t is the identity matrix. */
     isIdentity() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_is_identity", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Checks whether a matrix is singular.
-     */
+    /** Checks whether a matrix is singular. */
     isSingular() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_is_singular", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Multiplies two #graphene_matrix_t.
      *
      * Matrix multiplication is not commutative in general; the order of the factors matters.
      * The product of this multiplication is (`a` × `b`)
-     * @param b - a #graphene_matrix_t
-     * @param res - return location for the matrix
      */
     multiply(b, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_multiply", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1120,38 +1171,38 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_matrix_get_type",
                 },
-                value: b?.id ?? b,
+                value: b.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_matrix_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Compares the two given #graphene_matrix_t matrices and checks
      * whether their values are within the given `epsilon` of each
      * other.
-     * @param b - a #graphene_matrix_t
-     * @param epsilon - the threshold between the two matrices
      */
     near(b, epsilon) {
         return call("libgraphene-1.0.so.0", "graphene_matrix_near", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1160,29 +1211,31 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_matrix_get_type",
                 },
-                value: b?.id ?? b,
+                value: b.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: epsilon,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Normalizes the given #graphene_matrix_t.
-     * @param res - return location for the normalized matrix
-     */
+    /** Normalizes the given #graphene_matrix_t. */
     normalize(res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_normalize", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1191,46 +1244,49 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_matrix_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Applies a perspective of `depth` to the matrix.
-     * @param depth - the depth of the perspective
-     * @param res - return location for the
-     */
+    /** Applies a perspective of `depth` to the matrix. */
     perspective(depth, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_perspective", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: depth,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_matrix_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Prints the contents of a matrix to the standard error stream.
@@ -1243,25 +1299,23 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Projects a #graphene_point_t using the matrix `m`.
-     * @param p - a #graphene_point_t
-     * @param res - return location for the projected
-     */
+    /** Projects a #graphene_point_t using the matrix `m`. */
     projectPoint(p, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_project_point", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1270,38 +1324,38 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point_get_type",
                 },
-                value: p?.id ?? p,
+                value: p.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Projects all corners of a #graphene_rect_t using the given matrix.
      *
      * See also: graphene_matrix_project_point()
-     * @param r - a #graphene_rect_t
-     * @param res - return location for the projected
      */
     projectRect(r, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_project_rect", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1310,39 +1364,39 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: r?.id ?? r,
+                value: r.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneQuad",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_quad_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Projects a #graphene_rect_t using the given matrix.
      *
      * The resulting rectangle is the axis aligned bounding rectangle capable
      * of fully containing the projected rectangle.
-     * @param r - a #graphene_rect_t
-     * @param res - return location for the projected
      */
     projectRectBounds(r, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_project_rect_bounds", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1351,24 +1405,26 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: r?.id ?? r,
+                value: r.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Adds a rotation transformation to `m`, using the given `angle`
@@ -1376,47 +1432,49 @@ export class Matrix extends NativeObject {
      *
      * This is the equivalent of calling graphene_matrix_init_rotate() and
      * then multiplying the matrix `m` with the rotation matrix.
-     * @param angle - the rotation angle, in degrees
-     * @param axis - the rotation axis, as a #graphene_vec3_t
      */
     rotate(angle, axis) {
         call("libgraphene-1.0.so.0", "graphene_matrix_rotate", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: angle,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec3",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec3_get_type",
                 },
-                value: axis?.id ?? axis,
+                value: axis.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Adds a rotation transformation to `m`, using the given
      * #graphene_euler_t.
-     * @param e - a rotation described by a #graphene_euler_t
      */
     rotateEuler(e) {
         call("libgraphene-1.0.so.0", "graphene_matrix_rotate_euler", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1425,14 +1483,16 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneEuler",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_euler_get_type",
                 },
-                value: e?.id ?? e,
+                value: e.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Adds a rotation transformation to `m`, using the given
@@ -1440,14 +1500,13 @@ export class Matrix extends NativeObject {
      *
      * This is the equivalent of calling graphene_quaternion_to_matrix() and
      * then multiplying `m` with the rotation matrix.
-     * @param q - a rotation described by a #graphene_quaternion_t
      */
     rotateQuaternion(q) {
         call("libgraphene-1.0.so.0", "graphene_matrix_rotate_quaternion", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1456,86 +1515,100 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneQuaternion",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_quaternion_get_type",
                 },
-                value: q?.id ?? q,
+                value: q.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Adds a rotation transformation around the X axis to `m`, using
      * the given `angle`.
      *
      * See also: graphene_matrix_rotate()
-     * @param angle - the rotation angle, in degrees
      */
     rotateX(angle) {
         call("libgraphene-1.0.so.0", "graphene_matrix_rotate_x", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: angle,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Adds a rotation transformation around the Y axis to `m`, using
      * the given `angle`.
      *
      * See also: graphene_matrix_rotate()
-     * @param angle - the rotation angle, in degrees
      */
     rotateY(angle) {
         call("libgraphene-1.0.so.0", "graphene_matrix_rotate_y", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: angle,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Adds a rotation transformation around the Z axis to `m`, using
      * the given `angle`.
      *
      * See also: graphene_matrix_rotate()
-     * @param angle - the rotation angle, in degrees
      */
     rotateZ(angle) {
         call("libgraphene-1.0.so.0", "graphene_matrix_rotate_z", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: angle,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Adds a scaling transformation to `m`, using the three
@@ -1543,97 +1616,111 @@ export class Matrix extends NativeObject {
      *
      * This is the equivalent of calling graphene_matrix_init_scale() and then
      * multiplying the matrix `m` with the scale matrix.
-     * @param factorX - scaling factor on the X axis
-     * @param factorY - scaling factor on the Y axis
-     * @param factorZ - scaling factor on the Z axis
      */
     scale(factorX, factorY, factorZ) {
         call("libgraphene-1.0.so.0", "graphene_matrix_scale", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: factorX,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: factorY,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: factorZ,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Adds a skew of `factor` on the X and Y axis to the given matrix.
-     * @param factor - skew factor
-     */
+    /** Adds a skew of `factor` on the X and Y axis to the given matrix. */
     skewXy(factor) {
         call("libgraphene-1.0.so.0", "graphene_matrix_skew_xy", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: factor,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Adds a skew of `factor` on the X and Z axis to the given matrix.
-     * @param factor - skew factor
-     */
+    /** Adds a skew of `factor` on the X and Z axis to the given matrix. */
     skewXz(factor) {
         call("libgraphene-1.0.so.0", "graphene_matrix_skew_xz", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: factor,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Adds a skew of `factor` on the Y and Z axis to the given matrix.
-     * @param factor - skew factor
-     */
+    /** Adds a skew of `factor` on the Y and Z axis to the given matrix. */
     skewYz(factor) {
         call("libgraphene-1.0.so.0", "graphene_matrix_skew_yz", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: factor,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Converts a #graphene_matrix_t to an affine transformation
@@ -1642,68 +1729,99 @@ export class Matrix extends NativeObject {
      * The returned values have the following layout:
      *
      * |[<!-- language="plain" -->
-     * ⎛ xx  yx ⎞   ⎛  a   b  0 ⎞
-     * ⎜ xy  yy ⎟ = ⎜  c   d  0 ⎟
-     * ⎝ x0  y0 ⎠   ⎝ tx  ty  1 ⎠
+     *   ⎛ xx  yx ⎞   ⎛  a   b  0 ⎞
+     *   ⎜ xy  yy ⎟ = ⎜  c   d  0 ⎟
+     *   ⎝ x0  y0 ⎠   ⎝ tx  ty  1 ⎠
      * ]|
      *
      * This function can be used to convert between a #graphene_matrix_t
      * and an affine matrix type from other libraries.
-     * @param xx - return location for the xx member
-     * @param yx - return location for the yx member
-     * @param xy - return location for the xy member
-     * @param yy - return location for the yy member
-     * @param x_0 - return location for the x0 member
-     * @param y_0 - return location for the y0 member
      */
     to_2d(xx, yx, xy, yy, x_0, y_0) {
         return call("libgraphene-1.0.so.0", "graphene_matrix_to_2d", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "ref", innerType: { type: "float", size: 64 } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 64,
+                    },
+                },
                 value: xx,
             },
             {
-                type: { type: "ref", innerType: { type: "float", size: 64 } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 64,
+                    },
+                },
                 value: yx,
             },
             {
-                type: { type: "ref", innerType: { type: "float", size: 64 } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 64,
+                    },
+                },
                 value: xy,
             },
             {
-                type: { type: "ref", innerType: { type: "float", size: 64 } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 64,
+                    },
+                },
                 value: yy,
             },
             {
-                type: { type: "ref", innerType: { type: "float", size: 64 } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 64,
+                    },
+                },
                 value: x_0,
             },
             {
-                type: { type: "ref", innerType: { type: "float", size: 64 } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 64,
+                    },
+                },
                 value: y_0,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Converts a #graphene_matrix_t to an array of floating point
      * values.
-     * @param v - return location
      */
     toFloat(v) {
         call("libgraphene-1.0.so.0", "graphene_matrix_to_float", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1712,11 +1830,21 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "array", itemType: { type: "float", size: 32 } },
+                    innerType: {
+                        type: "array",
+                        itemType: {
+                            type: "float",
+                            size: 32,
+                        },
+                        listType: "array",
+                        ownership: "none",
+                    },
                 },
                 value: v,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Transforms each corner of a #graphene_rect_t using the given matrix `m`.
@@ -1725,15 +1853,13 @@ export class Matrix extends NativeObject {
      * quadrilateral.
      *
      * See also: graphene_matrix_transform_point()
-     * @param r - a #graphene_rect_t
-     * @param res - return location for the bounds
      */
     transformBounds(r, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_bounds", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1742,39 +1868,39 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: r?.id ?? r,
+                value: r.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Transforms the vertices of a #graphene_box_t using the given matrix `m`.
      *
      * The result is the axis aligned bounding box containing the transformed
      * vertices.
-     * @param b - a #graphene_box_t
-     * @param res - return location for the bounds
      */
     transformBox(b, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_box", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1783,24 +1909,26 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneBox",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_box_get_type",
                 },
-                value: b?.id ?? b,
+                value: b.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneBox",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_box_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Transforms the given #graphene_point_t using the matrix `m`.
@@ -1810,15 +1938,13 @@ export class Matrix extends NativeObject {
      * the dot product of each row vector of the matrix.
      *
      * See also: graphene_simd4x4f_point3_mul()
-     * @param p - a #graphene_point_t
-     * @param res - return location for the
      */
     transformPoint(p, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_point", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1827,24 +1953,26 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point_get_type",
                 },
-                value: p?.id ?? p,
+                value: p.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Transforms the given #graphene_point3d_t using the matrix `m`.
@@ -1854,15 +1982,13 @@ export class Matrix extends NativeObject {
      * the dot product of each row vector of the matrix.
      *
      * See also: graphene_simd4x4f_point3_mul()
-     * @param p - a #graphene_point3d_t
-     * @param res - return location for the result
      */
     transformPoint3d(p, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_point3d", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1871,36 +1997,34 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint3D",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point3d_get_type",
                 },
-                value: p?.id ?? p,
+                value: p.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint3D",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point3d_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Transform a #graphene_ray_t using the given matrix `m`.
-     * @param r - a #graphene_ray_t
-     * @param res - return location for the
-     */
+    /** Transform a #graphene_ray_t using the given matrix `m`. */
     transformRay(r, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_ray", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1909,24 +2033,26 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRay",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_ray_get_type",
                 },
-                value: r?.id ?? r,
+                value: r.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRay",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_ray_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Transforms each corner of a #graphene_rect_t using the given matrix `m`.
@@ -1934,15 +2060,13 @@ export class Matrix extends NativeObject {
      * The result is a coplanar quadrilateral.
      *
      * See also: graphene_matrix_transform_point()
-     * @param r - a #graphene_rect_t
-     * @param res - return location for the
      */
     transformRect(r, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_rect", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1951,37 +2075,37 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: r?.id ?? r,
+                value: r.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneQuad",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_quad_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Transforms a #graphene_sphere_t using the given matrix `m`. The
      * result is the bounding sphere containing the transformed sphere.
-     * @param s - a #graphene_sphere_t
-     * @param res - return location for the bounds
      */
     transformSphere(s, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_sphere", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -1990,24 +2114,26 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneSphere",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_sphere_get_type",
                 },
-                value: s?.id ?? s,
+                value: s.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneSphere",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_sphere_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Transforms the given #graphene_vec3_t using the matrix `m`.
@@ -2017,15 +2143,13 @@ export class Matrix extends NativeObject {
      * be ignored.
      *
      * See also: graphene_simd4x4f_vec3_mul()
-     * @param v - a #graphene_vec3_t
-     * @param res - return location for a #graphene_vec3_t
      */
     transformVec3(v, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_vec3", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -2034,38 +2158,38 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec3",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec3_get_type",
                 },
-                value: v?.id ?? v,
+                value: v.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec3",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec3_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Transforms the given #graphene_vec4_t using the matrix `m`.
      *
      * See also: graphene_simd4x4f_vec4_mul()
-     * @param v - a #graphene_vec4_t
-     * @param res - return location for a #graphene_vec4_t
      */
     transformVec4(v, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_vec4", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -2074,24 +2198,26 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec4",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec4_get_type",
                 },
-                value: v?.id ?? v,
+                value: v.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec4",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec4_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Adds a translation transformation to `m` using the coordinates
@@ -2099,14 +2225,13 @@ export class Matrix extends NativeObject {
      *
      * This is the equivalent of calling graphene_matrix_init_translate() and
      * then multiplying `m` with the translation matrix.
-     * @param pos - a #graphene_point3d_t
      */
     translate(pos) {
         call("libgraphene-1.0.so.0", "graphene_matrix_translate", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -2115,25 +2240,24 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint3D",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point3d_get_type",
                 },
-                value: pos?.id ?? pos,
+                value: pos.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Transposes the given matrix.
-     * @param res - return location for the
-     */
+    /** Transposes the given matrix. */
     transpose(res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transpose", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -2142,28 +2266,27 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_matrix_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Unprojects the given `point` using the `projection` matrix and
      * a `modelview` matrix.
-     * @param modelview - a #graphene_matrix_t for the modelview matrix; this is
-     * @param point - a #graphene_point3d_t with the coordinates of the point
-     * @param res - return location for the unprojected
      */
     unprojectPoint3d(modelview, point, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_unproject_point3d", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -2172,48 +2295,47 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_matrix_get_type",
                 },
-                value: modelview?.id ?? modelview,
+                value: modelview.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint3D",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point3d_get_type",
                 },
-                value: point?.id ?? point,
+                value: point.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint3D",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point3d_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Undoes the transformation on the corners of a #graphene_rect_t using the
      * given matrix, within the given axis aligned rectangular `bounds`.
-     * @param r - a #graphene_rect_t
-     * @param bounds - the bounds of the transformation
-     * @param res - return location for the
      */
     untransformBounds(r, bounds, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_untransform_bounds", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -2222,48 +2344,47 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: r?.id ?? r,
+                value: r.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: bounds?.id ?? bounds,
+                value: bounds.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Undoes the transformation of a #graphene_point_t using the
      * given matrix, within the given axis aligned rectangular `bounds`.
-     * @param p - a #graphene_point_t
-     * @param bounds - the bounds of the transformation
-     * @param res - return location for the
      */
     untransformPoint(p, bounds, res) {
         return call("libgraphene-1.0.so.0", "graphene_matrix_untransform_point", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                 },
@@ -2272,34 +2393,36 @@ export class Matrix extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point_get_type",
                 },
-                value: p?.id ?? p,
+                value: p.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: bounds?.id ?? bounds,
+                value: bounds.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point_get_type",
                 },
-                value: res?.id ?? res,
+                value: res.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
 }
 registerNativeClass(Matrix);