@gtkx/ffi 0.10.5 → 0.11.1

package/dist/generated/gtk/tree-store.js

@@ -1,7 +1,8 @@
 import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
-import { registerNativeClass, getNativeClass } from "../../registry.js";
+import { registerNativeClass } from "../../registry.js";
+import { TreeIter } from "./tree-iter.js";
 import { TreePath } from "./tree-path.js";
 import { TreeModel } from "./tree-model.js";
 import * as GObject from "../gobject/index.js";
@@ -38,102 +39,6 @@ import * as GObject from "../gobject/index.js";
  * </object>
  * ```
  */
-const SIGNAL_META = {
-    "row-changed": {
-        params: [
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreePath",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_path_get_type",
-            },
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreeIter",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_iter_get_type",
-            },
-        ],
-        returnType: { type: "undefined" },
-    },
-    "row-deleted": {
-        params: [
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreePath",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_path_get_type",
-            },
-        ],
-        returnType: { type: "undefined" },
-    },
-    "row-has-child-toggled": {
-        params: [
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreePath",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_path_get_type",
-            },
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreeIter",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_iter_get_type",
-            },
-        ],
-        returnType: { type: "undefined" },
-    },
-    "row-inserted": {
-        params: [
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreePath",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_path_get_type",
-            },
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreeIter",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_iter_get_type",
-            },
-        ],
-        returnType: { type: "undefined" },
-    },
-    "rows-reordered": {
-        params: [
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreePath",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_path_get_type",
-            },
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreeIter",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_iter_get_type",
-            },
-            { type: "int", size: 64, unsigned: true },
-        ],
-        returnType: { type: "undefined" },
-    },
-    "sort-column-changed": { params: [], returnType: { type: "undefined" } },
-    notify: {
-        params: [{ type: "gparam", borrowed: true }],
-        returnType: { type: "undefined" },
-    },
-};
 export class TreeStore extends GObject.GObject {
     static glibTypeName = "GtkTreeStore";
     static objectType = "gobject";
@@ -141,8 +46,6 @@ export class TreeStore extends GObject.GObject {
      * Creates a new tree store.
      *
      * This constructor is meant for language bindings.
-     * @param nColumns - number of columns in the tree store
-     * @param types - an array of `GType` types for the columns, from first to last
      */
     constructor(nColumns, types) {
         if (!isInstantiating) {
@@ -152,17 +55,29 @@ export class TreeStore extends GObject.GObject {
             setInstantiating(false);
             this.id = call("libgtk-4.so.1", "gtk_tree_store_newv", [
                 {
-                    type: { type: "int", size: 32, unsigned: false },
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                     value: nColumns,
+                    optional: false,
                 },
                 {
                     type: {
                         type: "array",
-                        itemType: { type: "int", size: 64, unsigned: true },
+                        itemType: {
+                            type: "int",
+                            size: 64,
+                            unsigned: true,
+                        },
+                        listType: "array",
+                        ownership: "none",
                     },
                     value: types,
+                    optional: false,
                 },
-            ], { type: "gobject", borrowed: false });
+            ], { type: "gobject", ownership: "full" });
         }
         else {
             // @ts-ignore
@@ -178,48 +93,54 @@ export class TreeStore extends GObject.GObject {
      * The `iter` parameter will be changed to point to this new row. The row will
      * be empty after this function is called. To fill in values, you need to call
      * gtk_tree_store_set() or gtk_tree_store_set_value().
-     * @param iter - An unset `GtkTreeIter` to set to the appended row
-     * @param parent - A valid `GtkTreeIter`
      */
     append(iter, parent) {
         call("libgtk-4.so.1", "gtk_tree_store_append", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: parent?.id ?? parent,
+                value: parent?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Removes all rows from `tree_store`
-     */
+    /** Removes all rows from `tree_store` */
     clear() {
         call("libgtk-4.so.1", "gtk_tree_store_clear", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Creates a new row at `position`.
@@ -233,42 +154,48 @@ export class TreeStore extends GObject.GObject {
      * The `iter` parameter will be changed to point to this new row. The row
      * will be empty after this function is called. To fill in values, you
      * need to call gtk_tree_store_set() or gtk_tree_store_set_value().
-     * @param iter - An unset `GtkTreeIter` to set to the new row
-     * @param parent - A valid `GtkTreeIter`
-     * @param position - position to insert the new row, or -1 for last
      */
     insert(iter, position, parent) {
         call("libgtk-4.so.1", "gtk_tree_store_insert", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: parent?.id ?? parent,
+                value: parent?.id,
                 optional: true,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: position,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Inserts a new row after `sibling`.
@@ -284,49 +211,51 @@ export class TreeStore extends GObject.GObject {
      * The `iter` parameter will be changed to point to this new row. The row will
      * be empty after this function is called. To fill in values, you need to call
      * gtk_tree_store_set() or gtk_tree_store_set_value().
-     * @param iter - An unset `GtkTreeIter` to set to the new row
-     * @param parent - A valid `GtkTreeIter`
-     * @param sibling - A valid `GtkTreeIter`
      */
     insertAfter(iter, parent, sibling) {
         call("libgtk-4.so.1", "gtk_tree_store_insert_after", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: parent?.id ?? parent,
+                value: parent?.id,
                 optional: true,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: sibling?.id ?? sibling,
+                value: sibling?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Inserts a new row before `sibling`.
@@ -342,98 +271,107 @@ export class TreeStore extends GObject.GObject {
      * The `iter` parameter will be changed to point to this new row. The row will
      * be empty after this function is called. To fill in values, you need to call
      * gtk_tree_store_set() or gtk_tree_store_set_value().
-     * @param iter - An unset `GtkTreeIter` to set to the new row
-     * @param parent - A valid `GtkTreeIter`
-     * @param sibling - A valid `GtkTreeIter`
      */
     insertBefore(iter, parent, sibling) {
         call("libgtk-4.so.1", "gtk_tree_store_insert_before", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: parent?.id ?? parent,
+                value: parent?.id,
                 optional: true,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: sibling?.id ?? sibling,
+                value: sibling?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * A variant of gtk_tree_store_insert_with_values() which takes
      * the columns and values as two arrays, instead of varargs.
      *
      * This function is mainly intended for language bindings.
-     * @param iter - An unset `GtkTreeIter` to set the new row
-     * @param parent - A valid `GtkTreeIter`
-     * @param position - position to insert the new row, or -1 for last
-     * @param columns - an array of column numbers
-     * @param values - an array of GValues
-     * @param nValues - the length of the `columns` and `values` arrays
      */
     insertWithValuesv(position, columns, values, nValues, iter, parent) {
         call("libgtk-4.so.1", "gtk_tree_store_insert_with_valuesv", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter?.id,
                 optional: true,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: parent?.id ?? parent,
+                value: parent?.id,
                 optional: true,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: position,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 32, unsigned: false },
+                    itemType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: columns,
             },
@@ -442,101 +380,121 @@ export class TreeStore extends GObject.GObject {
                     type: "array",
                     itemType: {
                         type: "boxed",
+                        ownership: "none",
                         innerType: "GValue",
                         lib: "libgobject-2.0.so.0",
                         getTypeFn: "g_value_get_type",
                     },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: values,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: nValues,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Checks if `iter` is an ancestor of `descendant`.
-     * @param iter - A valid `GtkTreeIter`
-     * @param descendant - A valid `GtkTreeIter`
-     */
+    /** Checks if `iter` is an ancestor of `descendant`. */
     isAncestor(iter, descendant) {
         return call("libgtk-4.so.1", "gtk_tree_store_is_ancestor", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: descendant?.id ?? descendant,
+                value: descendant.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Returns the depth of the position pointed by the iterator
      *
      * The depth will be 0 for anything on the root level, 1 for anything down
      * a level, etc.
-     * @param iter - A valid `GtkTreeIter`
      */
     iterDepth(iter) {
         return call("libgtk-4.so.1", "gtk_tree_store_iter_depth", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Checks if the given iter is a valid iter for this `GtkTreeStore`.
      *
      * This function is slow. Only use it for debugging and/or testing
      * purposes.
-     * @param iter - the iterator to check
      */
     iterIsValid(iter) {
         return call("libgtk-4.so.1", "gtk_tree_store_iter_is_valid", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `iter` in `tree_store` to the position after `position`.
@@ -546,37 +504,40 @@ export class TreeStore extends GObject.GObject {
      * Note that this function only works with unsorted stores.
      *
      * If `position` is %NULL, `iter` will be moved to the start of the level.
-     * @param iter - A `GtkTreeIter`.
-     * @param position - A `GtkTreeIter`.
      */
     moveAfter(iter, position) {
         call("libgtk-4.so.1", "gtk_tree_store_move_after", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: position?.id ?? position,
+                value: position?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Moves `iter` in `tree_store` to the position before `position`.
@@ -586,37 +547,40 @@ export class TreeStore extends GObject.GObject {
      * Note that this function only works with unsorted stores.
      *
      * If `position` is %NULL, `iter` will be moved to the end of the level.
-     * @param iter - A `GtkTreeIter`
-     * @param position - A `GtkTreeIter`
      */
     moveBefore(iter, position) {
         call("libgtk-4.so.1", "gtk_tree_store_move_before", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: position?.id ?? position,
+                value: position?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Prepends a new row to `tree_store`.
@@ -626,62 +590,69 @@ export class TreeStore extends GObject.GObject {
      * `iter` parameter will be changed to point to this new row.  The row will
      * be empty after this function is called. To fill in values, you need to
      * call gtk_tree_store_set() or gtk_tree_store_set_value().
-     * @param iter - An unset `GtkTreeIter` to set to the prepended row
-     * @param parent - A valid `GtkTreeIter`
      */
     prepend(iter, parent) {
         call("libgtk-4.so.1", "gtk_tree_store_prepend", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: parent?.id ?? parent,
+                value: parent?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Removes `iter` from `tree_store`.
      *
      * After being removed, `iter` is set to the next valid row at that level, or
      * invalidated if it previously pointed to the last one.
-     * @param iter - A valid `GtkTreeIter`
      */
     remove(iter) {
         return call("libgtk-4.so.1", "gtk_tree_store_remove", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Sets the type of the columns in a tree store.
@@ -693,68 +664,87 @@ export class TreeStore extends GObject.GObject {
      * This functions cannot be called after a row has been added,
      * or a method on the `GtkTreeModel` interface is called on the
      * tree store.
-     * @param nColumns - Number of columns for the tree store
-     * @param types - An array of `GType` types, one for each column
      */
     setColumnTypes(nColumns, types) {
         call("libgtk-4.so.1", "gtk_tree_store_set_column_types", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: nColumns,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 64, unsigned: true },
+                    itemType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: types,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the data in the cell specified by `iter` and `column`.
      *
      * The type of `value` must be convertible to the type of the
      * column.
-     * @param iter - A valid `GtkTreeIter` for the row being modified
-     * @param column - column number to modify
-     * @param value - new value for the cell
      */
     setValue(iter, column, value) {
         call("libgtk-4.so.1", "gtk_tree_store_set_value", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: column,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GValue",
                     lib: "libgobject-2.0.so.0",
                     getTypeFn: "g_value_get_type",
                 },
-                value: value?.id ?? value,
+                value: value.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * A variant of gtk_tree_store_set_valist() which takes
@@ -763,31 +753,36 @@ export class TreeStore extends GObject.GObject {
      *
      * This function is mainly intended for language bindings or in case
      * the number of columns to change is not known until run-time.
-     * @param iter - A valid `GtkTreeIter` for the row being modified
-     * @param columns - an array of column numbers
-     * @param values - an array of GValues
-     * @param nValues - the length of the `columns` and `values` arrays
      */
     setValuesv(iter, columns, values, nValues) {
         call("libgtk-4.so.1", "gtk_tree_store_set_valuesv", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 32, unsigned: false },
+                    itemType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: columns,
             },
@@ -796,53 +791,65 @@ export class TreeStore extends GObject.GObject {
                     type: "array",
                     itemType: {
                         type: "boxed",
+                        ownership: "none",
                         innerType: "GValue",
                         lib: "libgobject-2.0.so.0",
                         getTypeFn: "g_value_get_type",
                     },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: values,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: nValues,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Swaps `a` and `b` in the same level of `tree_store`.
      *
      * Note that this function only works with unsorted stores.
-     * @param a - A `GtkTreeIter`.
-     * @param b - Another `GtkTreeIter`.
      */
     swap(a, b) {
         call("libgtk-4.so.1", "gtk_tree_store_swap", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: a?.id ?? a,
+                value: a.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: b?.id ?? b,
+                value: b.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Gets the ID of the `buildable` object.
@@ -853,10 +860,16 @@ export class TreeStore extends GObject.GObject {
     getBuildableId() {
         return call("libgtk-4.so.1", "gtk_buildable_get_buildable_id", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "string", borrowed: true });
+        ], {
+            type: "string",
+            ownership: "none",
+        });
     }
     /**
      * Asks the `GtkTreeDragDest` to insert a row before the path `dest`,
@@ -865,36 +878,39 @@ export class TreeStore extends GObject.GObject {
      * will be returned. Also, %FALSE may be returned if the new row is
      * not created for some model-specific reason.  Should robustly handle
      * a `dest` no longer found in the model!
-     * @param dest - row to drop in front of
-     * @param value - data to drop
      */
     dragDataReceived(dest, value) {
         return call("libgtk-4.so.1", "gtk_tree_drag_dest_drag_data_received", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreePath",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_path_get_type",
                 },
-                value: dest?.id ?? dest,
+                value: dest.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GValue",
                     lib: "libgobject-2.0.so.0",
                     getTypeFn: "g_value_get_type",
                 },
-                value: value?.id ?? value,
+                value: value.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Determines whether a drop is possible before the given `dest_path`,
@@ -902,36 +918,39 @@ export class TreeStore extends GObject.GObject {
      * `value` at that location. `dest_path` does not have to
      * exist; the return value will almost certainly be %FALSE if the
      * parent of `dest_path` doesn’t exist, though.
-     * @param destPath - destination row
-     * @param value - the data being dropped
      */
     rowDropPossible(destPath, value) {
         return call("libgtk-4.so.1", "gtk_tree_drag_dest_row_drop_possible", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreePath",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_path_get_type",
                 },
-                value: destPath?.id ?? destPath,
+                value: destPath.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GValue",
                     lib: "libgobject-2.0.so.0",
                     getTypeFn: "g_value_get_type",
                 },
-                value: value?.id ?? value,
+                value: value.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Asks the `GtkTreeDragSource` to delete the row at `path`, because
@@ -939,49 +958,58 @@ export class TreeStore extends GObject.GObject {
      * if the deletion fails because `path` no longer exists, or for
      * some model-specific reason. Should robustly handle a `path` no
      * longer found in the model!
-     * @param path - row that was being dragged
      */
     dragDataDelete(path) {
         return call("libgtk-4.so.1", "gtk_tree_drag_source_drag_data_delete", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreePath",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_path_get_type",
                 },
-                value: path?.id ?? path,
+                value: path.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
      * the row at `path`. Should robustly handle a `path` no
      * longer found in the model!
-     * @param path - row that was dragged
      */
     dragDataGet(path) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_drag_source_drag_data_get", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreePath",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_path_get_type",
                 },
-                value: path?.id ?? path,
+                value: path.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
@@ -990,66 +1018,83 @@ export class TreeStore extends GObject.GObject {
      * Asks the `GtkTreeDragSource` whether a particular row can be used as
      * the source of a DND operation. If the source doesn’t implement
      * this interface, the row is assumed draggable.
-     * @param path - row on which user is initiating a drag
      */
     rowDraggable(path) {
         return call("libgtk-4.so.1", "gtk_tree_drag_source_row_draggable", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreePath",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_path_get_type",
                 },
-                value: path?.id ?? path,
+                value: path.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Creates a new `GtkTreeModel`, with `child_model` as the child_model
      * and `root` as the virtual root.
-     * @param root - A `GtkTreePath`
      */
     filterNew(root) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_model_filter_new", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreePath",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_path_get_type",
                 },
-                value: root?.id ?? root,
+                value: root?.id,
                 optional: true,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         return getNativeObject(ptr, TreeModel);
     }
-    /**
-     * Returns the type of the column.
-     * @param index_ - the column index
-     */
+    /** Returns the type of the column. */
     getColumnType(index_) {
         return call("libgtk-4.so.1", "gtk_tree_model_get_column_type", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: index_,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
     /**
      * Returns a set of flags supported by this interface.
@@ -1061,138 +1106,165 @@ export class TreeStore extends GObject.GObject {
     getFlags() {
         return call("libgtk-4.so.1", "gtk_tree_model_get_flags", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: true });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
     }
     /**
      * Sets `iter` to a valid iterator pointing to `path`.
      *
      * If `path` does not exist, `iter` is set to an invalid
      * iterator and %FALSE is returned.
-     * @param iter - the uninitialized `GtkTreeIter`
-     * @param path - the `GtkTreePath`
      */
     getIter(iter, path) {
         return call("libgtk-4.so.1", "gtk_tree_model_get_iter", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreePath",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_path_get_type",
                 },
-                value: path?.id ?? path,
+                value: path.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Initializes `iter` with the first iterator in the tree
      * (the one at the path "0").
      *
      * Returns %FALSE if the tree is empty, %TRUE otherwise.
-     * @param iter - the uninitialized `GtkTreeIter`
      */
     getIterFirst(iter) {
         return call("libgtk-4.so.1", "gtk_tree_model_get_iter_first", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Sets `iter` to a valid iterator pointing to `path_string`, if it
      * exists.
      *
      * Otherwise, `iter` is left invalid and %FALSE is returned.
-     * @param iter - an uninitialized `GtkTreeIter`
-     * @param pathString - a string representation of a `GtkTreePath`
      */
     getIterFromString(iter, pathString) {
         return call("libgtk-4.so.1", "gtk_tree_model_get_iter_from_string", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: pathString,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Returns the number of columns supported by `tree_model`.
-     */
+    /** Returns the number of columns supported by `tree_model`. */
     getNColumns() {
         return call("libgtk-4.so.1", "gtk_tree_model_get_n_columns", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Returns a newly-created `GtkTreePath` referenced by `iter`.
      *
      * This path should be freed with gtk_tree_path_free().
-     * @param iter - the `GtkTreeIter`
      */
     getPath(iter) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_model_get_path", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "GtkTreePath",
             lib: "libgtk-4.so.1",
             getTypeFn: "gtk_tree_path_get_type",
@@ -1205,66 +1277,77 @@ export class TreeStore extends GObject.GObject {
      * This string is a “:” separated list of numbers.
      * For example, “4:10:0:3” would be an acceptable
      * return value for this string.
-     * @param iter - a `GtkTreeIter`
      */
     getStringFromIter(iter) {
         return call("libgtk-4.so.1", "gtk_tree_model_get_string_from_iter", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
-        ], { type: "string" });
+        ], {
+            type: "string",
+            ownership: "full",
+        });
     }
     /**
      * Initializes and sets `value` to that at `column`.
      *
      * When done with `value`, g_value_unset() needs to be called
      * to free any allocated memory.
-     * @param iter - the `GtkTreeIter`
-     * @param column - the column to lookup the value at
-     * @param value - an empty `GValue` to set
      */
     getValue(iter, column, value) {
         call("libgtk-4.so.1", "gtk_tree_model_get_value", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: column,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GValue",
                     lib: "libgobject-2.0.so.0",
                     getTypeFn: "g_value_get_type",
                 },
-                value: value?.id ?? value,
+                value: value.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets `iter` to point to the first child of `parent`.
@@ -1275,110 +1358,125 @@ export class TreeStore extends GObject.GObject {
      *
      * If `parent` is %NULL returns the first node, equivalent to
      * `gtk_tree_model_get_iter_first (tree_model, iter);`
-     * @param iter - the new `GtkTreeIter` to be set to the child
-     * @param parent - the `GtkTreeIter`
      */
     iterChildren(iter, parent) {
         return call("libgtk-4.so.1", "gtk_tree_model_iter_children", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: parent?.id ?? parent,
+                value: parent?.id,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Returns %TRUE if `iter` has children, %FALSE otherwise.
-     * @param iter - the `GtkTreeIter` to test for children
-     */
+    /** Returns %TRUE if `iter` has children, %FALSE otherwise. */
     iterHasChild(iter) {
         return call("libgtk-4.so.1", "gtk_tree_model_iter_has_child", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Returns the number of children that `iter` has.
      *
      * As a special case, if `iter` is %NULL, then the number
      * of toplevel nodes is returned.
-     * @param iter - the `GtkTreeIter`
      */
     iterNChildren(iter) {
         return call("libgtk-4.so.1", "gtk_tree_model_iter_n_children", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter?.id,
                 optional: true,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Sets `iter` to point to the node following it at the current level.
      *
      * If there is no next `iter`, %FALSE is returned and `iter` is set
      * to be invalid.
-     * @param iter - the `GtkTreeIter`
      */
     iterNext(iter) {
         return call("libgtk-4.so.1", "gtk_tree_model_iter_next", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Sets `iter` to be the child of `parent`, using the given index.
@@ -1388,42 +1486,48 @@ export class TreeStore extends GObject.GObject {
      * will remain a valid node after this function has been called. As a
      * special case, if `parent` is %NULL, then the `n`-th root node
      * is set.
-     * @param iter - the `GtkTreeIter` to set to the nth child
-     * @param parent - the `GtkTreeIter` to get the child from
-     * @param n - the index of the desired child
      */
     iterNthChild(iter, n, parent) {
         return call("libgtk-4.so.1", "gtk_tree_model_iter_nth_child", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: parent?.id ?? parent,
+                value: parent?.id,
                 optional: true,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: n,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Sets `iter` to be the parent of `child`.
@@ -1435,61 +1539,68 @@ export class TreeStore extends GObject.GObject {
      *
      * `iter` will be initialized before the lookup is performed, so `child`
      * and `iter` cannot point to the same memory location.
-     * @param iter - the new `GtkTreeIter` to set to the parent
-     * @param child - the `GtkTreeIter`
      */
     iterParent(iter, child) {
         return call("libgtk-4.so.1", "gtk_tree_model_iter_parent", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: child?.id ?? child,
+                value: child.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Sets `iter` to point to the previous node at the current level.
      *
      * If there is no previous `iter`, %FALSE is returned and `iter` is
      * set to be invalid.
-     * @param iter - the `GtkTreeIter`
      */
     iterPrevious(iter) {
         return call("libgtk-4.so.1", "gtk_tree_model_iter_previous", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Lets the tree ref the node.
@@ -1509,60 +1620,67 @@ export class TreeStore extends GObject.GObject {
      *
      * A model should be expected to be able to get an iter independent
      * of its reffed state.
-     * @param iter - the `GtkTreeIter`
      */
     refNode(iter) {
         call("libgtk-4.so.1", "gtk_tree_model_ref_node", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Emits the ::row-changed signal on `tree_model`.
      *
      * See {@link Gtk.TreeModel.:row-changed}.
-     * @param path - a `GtkTreePath` pointing to the changed row
-     * @param iter - a valid `GtkTreeIter` pointing to the changed row
      */
     rowChanged(path, iter) {
         call("libgtk-4.so.1", "gtk_tree_model_row_changed", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreePath",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_path_get_type",
                 },
-                value: path?.id ?? path,
+                value: path.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Emits the ::row-deleted signal on `tree_model`.
@@ -1575,25 +1693,29 @@ export class TreeStore extends GObject.GObject {
      *
      * Nodes that are deleted are not unreffed, this means that any
      * outstanding references on the deleted node should not be released.
-     * @param path - a `GtkTreePath` pointing to the previous location of
      */
     rowDeleted(path) {
         call("libgtk-4.so.1", "gtk_tree_model_row_deleted", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreePath",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_path_get_type",
                 },
-                value: path?.id ?? path,
+                value: path.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Emits the ::row-has-child-toggled signal on `tree_model`.
@@ -1602,71 +1724,77 @@ export class TreeStore extends GObject.GObject {
      *
      * This should be called by models after the child
      * state of a node changes.
-     * @param path - a `GtkTreePath` pointing to the changed row
-     * @param iter - a valid `GtkTreeIter` pointing to the changed row
      */
     rowHasChildToggled(path, iter) {
         call("libgtk-4.so.1", "gtk_tree_model_row_has_child_toggled", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreePath",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_path_get_type",
                 },
-                value: path?.id ?? path,
+                value: path.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Emits the ::row-inserted signal on `tree_model`.
      *
      * See {@link Gtk.TreeModel.:row-inserted}.
-     * @param path - a `GtkTreePath` pointing to the inserted row
-     * @param iter - a valid `GtkTreeIter` pointing to the inserted row
      */
     rowInserted(path, iter) {
         call("libgtk-4.so.1", "gtk_tree_model_row_inserted", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreePath",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_path_get_type",
                 },
-                value: path?.id ?? path,
+                value: path.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Emits the ::rows-reordered signal on `tree_model`.
@@ -1675,50 +1803,61 @@ export class TreeStore extends GObject.GObject {
      *
      * This should be called by models when their rows have been
      * reordered.
-     * @param path - a `GtkTreePath` pointing to the tree node whose children
-     * @param iter - a valid `GtkTreeIter` pointing to the node
-     * @param newOrder - an array of integers
-     * @param length - length of `new_order` array
      */
     rowsReorderedWithLength(path, newOrder, length, iter) {
         call("libgtk-4.so.1", "gtk_tree_model_rows_reordered_with_length", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreePath",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_path_get_type",
                 },
-                value: path?.id ?? path,
+                value: path.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter?.id,
                 optional: true,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 32, unsigned: false },
+                    itemType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: newOrder,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: length,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Lets the tree unref the node.
@@ -1729,55 +1868,70 @@ export class TreeStore extends GObject.GObject {
      * this means, see gtk_tree_model_ref_node().
      *
      * Please note that nodes that are deleted are not unreffed.
-     * @param iter - the `GtkTreeIter`
      */
     unrefNode(iter) {
         call("libgtk-4.so.1", "gtk_tree_model_unref_node", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Fills in `sort_column_id` and `order` with the current sort column and the
      * order. It returns %TRUE unless the `sort_column_id` is
      * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
      * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
-     * @param sortColumnId - The sort column id to be filled in
-     * @param order - The `GtkSortType` to be filled in
      */
     getSortColumnId(sortColumnId, order) {
         return call("libgtk-4.so.1", "gtk_tree_sortable_get_sort_column_id", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: sortColumnId,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: order,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Returns %TRUE if the model has a default sort function. This is used
@@ -1787,10 +1941,15 @@ export class TreeStore extends GObject.GObject {
     hasDefaultSortFunc() {
         return call("libgtk-4.so.1", "gtk_tree_sortable_has_default_sort_func", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Sets the current sort column to be `sort_column_id`. The `sortable` will
@@ -1799,74 +1958,262 @@ export class TreeStore extends GObject.GObject {
      * a regular column id, or one of the following special values:
      *
      * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
-     * will be used, if it is set
+     *   will be used, if it is set
      *
      * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
-     * @param sortColumnId - the sort column id to set
-     * @param order - The sort order of the column
      */
     setSortColumnId(sortColumnId, order) {
         call("libgtk-4.so.1", "gtk_tree_sortable_set_sort_column_id", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: sortColumnId,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: order,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
-     */
+    /** Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`. */
     sortColumnChanged() {
         call("libgtk-4.so.1", "gtk_tree_sortable_sort_column_changed", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     connect(signal, handler, after = false) {
-        const meta = SIGNAL_META[signal];
-        const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
-        const returnType = meta?.returnType;
-        const wrappedHandler = (...args) => {
-            const self = getNativeObject(args[0]);
-            const callbackArgs = args.slice(1);
-            if (!meta)
-                return handler(self, ...callbackArgs);
-            const wrapped = meta.params.map((t, i) => {
-                if (t?.type === "gobject" && callbackArgs[i] != null) {
-                    return getNativeObject(callbackArgs[i]);
-                }
-                if (t?.type === "gparam" && callbackArgs[i] != null) {
-                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
-                }
-                if (t?.type === "boxed" && callbackArgs[i] != null) {
-                    const cls = getNativeClass(t.innerType);
-                    return cls ? getNativeObject(callbackArgs[i], cls) : callbackArgs[i];
-                }
-                return callbackArgs[i];
-            });
-            const result = handler(self, ...wrapped);
-            return result;
-        };
-        return call("libgtk-4.so.1", "g_signal_connect_closure", [
-            { type: { type: "gobject" }, value: this.id },
-            { type: { type: "string" }, value: signal },
-            {
-                type: { type: "callback", argTypes, returnType },
-                value: wrappedHandler,
-            },
-            { type: { type: "boolean" }, value: after },
-        ], { type: "int", size: 64, unsigned: true });
+        switch (signal) {
+            case "row-changed": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1], TreePath), getNativeObject(args[2], TreeIter));
+                };
+                return call("libgtk-4.so.1", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [
+                                { type: "gobject", ownership: "none" },
+                                {
+                                    type: "boxed",
+                                    ownership: "none",
+                                    innerType: "GtkTreePath",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gtk_tree_path_get_type",
+                                },
+                                {
+                                    type: "boxed",
+                                    ownership: "none",
+                                    innerType: "GtkTreeIter",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gtk_tree_iter_get_type",
+                                },
+                            ],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "row-deleted": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1], TreePath));
+                };
+                return call("libgtk-4.so.1", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [
+                                { type: "gobject", ownership: "none" },
+                                {
+                                    type: "boxed",
+                                    ownership: "none",
+                                    innerType: "GtkTreePath",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gtk_tree_path_get_type",
+                                },
+                            ],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "row-has-child-toggled": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1], TreePath), getNativeObject(args[2], TreeIter));
+                };
+                return call("libgtk-4.so.1", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [
+                                { type: "gobject", ownership: "none" },
+                                {
+                                    type: "boxed",
+                                    ownership: "none",
+                                    innerType: "GtkTreePath",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gtk_tree_path_get_type",
+                                },
+                                {
+                                    type: "boxed",
+                                    ownership: "none",
+                                    innerType: "GtkTreeIter",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gtk_tree_iter_get_type",
+                                },
+                            ],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "row-inserted": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1], TreePath), getNativeObject(args[2], TreeIter));
+                };
+                return call("libgtk-4.so.1", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [
+                                { type: "gobject", ownership: "none" },
+                                {
+                                    type: "boxed",
+                                    ownership: "none",
+                                    innerType: "GtkTreePath",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gtk_tree_path_get_type",
+                                },
+                                {
+                                    type: "boxed",
+                                    ownership: "none",
+                                    innerType: "GtkTreeIter",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gtk_tree_iter_get_type",
+                                },
+                            ],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "rows-reordered": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1], TreePath), getNativeObject(args[2], TreeIter), args[3]);
+                };
+                return call("libgtk-4.so.1", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [
+                                { type: "gobject", ownership: "none" },
+                                {
+                                    type: "boxed",
+                                    ownership: "none",
+                                    innerType: "GtkTreePath",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gtk_tree_path_get_type",
+                                },
+                                {
+                                    type: "boxed",
+                                    ownership: "none",
+                                    innerType: "GtkTreeIter",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gtk_tree_iter_get_type",
+                                },
+                                {
+                                    type: "int",
+                                    size: 64,
+                                    unsigned: true,
+                                },
+                            ],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "sort-column-changed": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]));
+                };
+                return call("libgtk-4.so.1", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [{ type: "gobject", ownership: "none" }],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            default:
+                return super.connect(signal, handler, after);
+        }
     }
 }
 registerNativeClass(TreeStore);