@gtkx/ffi 0.10.5 → 0.11.0

package/dist/generated/gtk/list-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";
@@ -150,102 +151,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 ListStore extends GObject.GObject {
     static glibTypeName = "GtkListStore";
     static objectType = "gobject";
@@ -253,8 +158,6 @@ export class ListStore extends GObject.GObject {
      * Creates a new `GtkListStore`.
      *
      * This function is meant to be used by language bindings.
-     * @param nColumns - number of columns in the list store
-     * @param types - an array of `GType` types for the columns, from first to last
      */
     constructor(nColumns, types) {
         if (!isInstantiating) {
@@ -264,17 +167,29 @@ export class ListStore extends GObject.GObject {
             setInstantiating(false);
             this.id = call("libgtk-4.so.1", "gtk_list_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
@@ -285,36 +200,43 @@ export class ListStore extends GObject.GObject {
      * Appends a new row to `list_store`.  `iter` 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_list_store_set() or gtk_list_store_set_value().
-     * @param iter - An unset `GtkTreeIter` to set to the appended row
      */
     append(iter) {
         call("libgtk-4.so.1", "gtk_list_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: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Removes all rows from the list store.
-     */
+    /** Removes all rows from the list store. */
     clear() {
         call("libgtk-4.so.1", "gtk_list_store_clear", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Creates a new row at `position`.  `iter` will be changed to point to this new
@@ -322,104 +244,117 @@ export class ListStore extends GObject.GObject {
      * then the new row will be appended to the list. The row will be empty after
      * this function is called.  To fill in values, you need to call
      * gtk_list_store_set() or gtk_list_store_set_value().
-     * @param iter - An unset `GtkTreeIter` to set to the new row
-     * @param position - position to insert the new row, or -1 for last
      */
     insert(iter, position) {
         call("libgtk-4.so.1", "gtk_list_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: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: position,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Inserts a new row after `sibling`. If `sibling` is %NULL, then the row will be
      * prepended to the beginning of the list. `iter` 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_list_store_set() or gtk_list_store_set_value().
-     * @param iter - An unset `GtkTreeIter` to set to the new row
-     * @param sibling - A valid `GtkTreeIter`
      */
     insertAfter(iter, sibling) {
         call("libgtk-4.so.1", "gtk_list_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: sibling?.id ?? sibling,
+                value: sibling?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Inserts a new row before `sibling`. If `sibling` is %NULL, then the row will
      * be appended to the end of the list. `iter` 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_list_store_set() or gtk_list_store_set_value().
-     * @param iter - An unset `GtkTreeIter` to set to the new row
-     * @param sibling - A valid `GtkTreeIter`
      */
     insertBefore(iter, sibling) {
         call("libgtk-4.so.1", "gtk_list_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: sibling?.id ?? sibling,
+                value: sibling?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * A variant of gtk_list_store_insert_with_values() which
@@ -427,37 +362,45 @@ export class ListStore extends GObject.GObject {
      * varargs.
      *
      * This function is mainly intended for language-bindings.
-     * @param iter - An unset `GtkTreeIter` to set to the new row
-     * @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) {
         call("libgtk-4.so.1", "gtk_list_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: "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,
             },
@@ -466,183 +409,220 @@ export class ListStore 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 the given iter is a valid iter for this `GtkListStore`.
      *
      * 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_list_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 `store` to the position after `position`. Note that this
      * function only works with unsorted stores. If `position` is %NULL, `iter`
      * will be moved to the start of the list.
-     * @param iter - A `GtkTreeIter`
-     * @param position - A `GtkTreeIter`
      */
     moveAfter(iter, position) {
         call("libgtk-4.so.1", "gtk_list_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 `store` to the position before `position`. Note that this
      * function only works with unsorted stores. If `position` is %NULL, `iter`
      * will be moved to the end of the list.
-     * @param iter - A `GtkTreeIter`
-     * @param position - A `GtkTreeIter`
      */
     moveBefore(iter, position) {
         call("libgtk-4.so.1", "gtk_list_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 `list_store`. `iter` 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_list_store_set() or gtk_list_store_set_value().
-     * @param iter - An unset `GtkTreeIter` to set to the prepend row
      */
     prepend(iter) {
         call("libgtk-4.so.1", "gtk_list_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: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Removes the given row from the list store.  After being removed,
      * `iter` is set to be the next valid row, or invalidated if it pointed
      * to the last row in `list_store`.
-     * @param iter - A valid `GtkTreeIter`
      */
     remove(iter) {
         return call("libgtk-4.so.1", "gtk_list_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",
+        });
     }
     /**
      * Reorders `store` to follow the order indicated by `new_order`. Note that
      * this function only works with unsorted stores.
-     * @param newOrder - an array of integers mapping the new
      */
     reorder(newOrder) {
         call("libgtk-4.so.1", "gtk_list_store_reorder", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 32, unsigned: false },
+                    itemType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: newOrder,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the types of the columns of a list store.
@@ -653,67 +633,86 @@ export class ListStore extends GObject.GObject {
      *
      * This function cannot be called after a row has been added, or
      * a method on the `GtkTreeModel` interface is called.
-     * @param nColumns - Number of columns for the list store
-     * @param types - An array length n of `GType`s
      */
     setColumnTypes(nColumns, types) {
         call("libgtk-4.so.1", "gtk_list_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_list_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_list_store_set_valist() which
@@ -721,31 +720,36 @@ export class ListStore extends GObject.GObject {
      * varargs. This function is mainly intended for
      * language-bindings and 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_list_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,
             },
@@ -754,52 +758,64 @@ export class ListStore 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 `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_list_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.
@@ -810,10 +826,16 @@ export class ListStore 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`,
@@ -822,36 +844,39 @@ export class ListStore 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`,
@@ -859,36 +884,39 @@ export class ListStore 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
@@ -896,49 +924,58 @@ export class ListStore 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);
@@ -947,66 +984,83 @@ export class ListStore 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.
@@ -1018,138 +1072,165 @@ export class ListStore 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",
@@ -1162,66 +1243,77 @@ export class ListStore 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`.
@@ -1232,110 +1324,125 @@ export class ListStore 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.
@@ -1345,42 +1452,48 @@ export class ListStore 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`.
@@ -1392,61 +1505,68 @@ export class ListStore 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.
@@ -1466,60 +1586,67 @@ export class ListStore 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`.
@@ -1532,25 +1659,29 @@ export class ListStore 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`.
@@ -1559,71 +1690,77 @@ export class ListStore 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`.
@@ -1632,50 +1769,61 @@ export class ListStore 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.
@@ -1686,55 +1834,70 @@ export class ListStore 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
@@ -1744,10 +1907,15 @@ export class ListStore 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
@@ -1756,74 +1924,262 @@ export class ListStore 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(ListStore);