@gtkx/ffi 0.10.4 → 0.11.0

package/dist/generated/gtk/tree-model-sort.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";
@@ -103,109 +104,10 @@ import * as GObject from "../gobject/index.js";
  * }
  * ```
  */
-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 TreeModelSort extends GObject.GObject {
     static glibTypeName = "GtkTreeModelSort";
     static objectType = "gobject";
-    /**
-     * Creates a new `GtkTreeModelSort`, with `child_model` as the child model.
-     * @param childModel - A `GtkTreeModel`
-     */
+    /** Creates a new `GtkTreeModelSort`, with `child_model` as the child model. */
     constructor(childModel) {
         if (!isInstantiating) {
             setInstantiating(true);
@@ -214,10 +116,14 @@ export class TreeModelSort extends GObject.GObject {
             setInstantiating(false);
             this.id = call("libgtk-4.so.1", "gtk_tree_model_sort_new_with_model", [
                 {
-                    type: { type: "gobject", borrowed: true },
-                    value: childModel?.id ?? childModel,
+                    type: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    value: childModel.id,
+                    optional: false,
                 },
-            ], { type: "gobject", borrowed: false });
+            ], { type: "gobject", ownership: "full" });
         }
         else {
             // @ts-ignore
@@ -235,72 +141,82 @@ export class TreeModelSort extends GObject.GObject {
     clearCache() {
         call("libgtk-4.so.1", "gtk_tree_model_sort_clear_cache", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets `sort_iter` to point to the row in `tree_model_sort` that corresponds to
      * the row pointed at by `child_iter`.  If `sort_iter` was not set, %FALSE
      * is returned.  Note: a boolean is only returned since 2.14.
-     * @param sortIter - An uninitialized `GtkTreeIter`
-     * @param childIter - A valid `GtkTreeIter` pointing to a row on the child model
      */
     convertChildIterToIter(sortIter, childIter) {
         return call("libgtk-4.so.1", "gtk_tree_model_sort_convert_child_iter_to_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: sortIter?.id ?? sortIter,
+                value: sortIter.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: childIter?.id ?? childIter,
+                value: childIter.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Converts `child_path` to a path relative to `tree_model_sort`.  That is,
      * `child_path` points to a path in the child model.  The returned path will
      * point to the same row in the sorted model.  If `child_path` isn’t a valid
      * path on the child model, then %NULL is returned.
-     * @param childPath - A `GtkTreePath` to convert
      */
     convertChildPathToPath(childPath) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_model_sort_convert_child_path_to_path", [
             {
-                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: childPath?.id ?? childPath,
+                value: childPath.id,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "GtkTreePath",
             lib: "libgtk-4.so.1",
             getTypeFn: "gtk_tree_path_get_type",
@@ -309,38 +225,39 @@ export class TreeModelSort extends GObject.GObject {
             return null;
         return getNativeObject(ptr, TreePath);
     }
-    /**
-     * Sets `child_iter` to point to the row pointed to by `sorted_iter`.
-     * @param childIter - An uninitialized `GtkTreeIter`
-     * @param sortedIter - A valid `GtkTreeIter` pointing to a row on `tree_model_sort`.
-     */
+    /** Sets `child_iter` to point to the row pointed to by `sorted_iter`. */
     convertIterToChildIter(childIter, sortedIter) {
         call("libgtk-4.so.1", "gtk_tree_model_sort_convert_iter_to_child_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: childIter?.id ?? childIter,
+                value: childIter.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: sortedIter?.id ?? sortedIter,
+                value: sortedIter.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Converts `sorted_path` to a path on the child model of `tree_model_sort`.
@@ -348,27 +265,29 @@ export class TreeModelSort extends GObject.GObject {
      * returned path will point to the same location in the model not being
      * sorted.  If `sorted_path` does not point to a location in the child model,
      * %NULL is returned.
-     * @param sortedPath - A `GtkTreePath` to convert
      */
     convertPathToChildPath(sortedPath) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_model_sort_convert_path_to_child_path", [
             {
-                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: sortedPath?.id ?? sortedPath,
+                value: sortedPath.id,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "GtkTreePath",
             lib: "libgtk-4.so.1",
             getTypeFn: "gtk_tree_path_get_type",
@@ -377,16 +296,20 @@ export class TreeModelSort extends GObject.GObject {
             return null;
         return getNativeObject(ptr, TreePath);
     }
-    /**
-     * Returns the model the `GtkTreeModelSort` is sorting.
-     */
+    /** Returns the model the `GtkTreeModelSort` is sorting. */
     getModel() {
         const ptr = call("libgtk-4.so.1", "gtk_tree_model_sort_get_model", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         return getNativeObject(ptr, TreeModel);
     }
     /**
@@ -394,25 +317,29 @@ export class TreeModelSort extends GObject.GObject {
      * > purposes.
      *
      * Checks if the given iter is a valid iter for this `GtkTreeModelSort`.
-     * @param iter - A `GtkTreeIter`
      */
     iterIsValid(iter) {
         return call("libgtk-4.so.1", "gtk_tree_model_sort_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",
+        });
     }
     /**
      * This resets the default sort function to be in the “unsorted” state.  That
@@ -423,10 +350,15 @@ export class TreeModelSort extends GObject.GObject {
     resetDefaultSortFunc() {
         call("libgtk-4.so.1", "gtk_tree_model_sort_reset_default_sort_func", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Asks the `GtkTreeDragSource` to delete the row at `path`, because
@@ -434,49 +366,58 @@ export class TreeModelSort 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);
@@ -485,66 +426,83 @@ export class TreeModelSort 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.
@@ -556,138 +514,165 @@ export class TreeModelSort 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",
@@ -700,66 +685,77 @@ export class TreeModelSort 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`.
@@ -770,110 +766,125 @@ export class TreeModelSort 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.
@@ -883,42 +894,48 @@ export class TreeModelSort 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`.
@@ -930,61 +947,68 @@ export class TreeModelSort 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.
@@ -1004,60 +1028,67 @@ export class TreeModelSort 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`.
@@ -1070,25 +1101,29 @@ export class TreeModelSort 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`.
@@ -1097,71 +1132,77 @@ export class TreeModelSort 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`.
@@ -1170,50 +1211,61 @@ export class TreeModelSort 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.
@@ -1224,55 +1276,70 @@ export class TreeModelSort 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
@@ -1282,10 +1349,15 @@ export class TreeModelSort 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
@@ -1294,74 +1366,262 @@ export class TreeModelSort 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(TreeModelSort);