@gtkx/ffi 0.10.5 → 0.11.0

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

@@ -1,13 +1,13 @@
 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 { Editable } from "./editable.js";
 import { TreeModel } from "./tree-model.js";
-import * as GObject from "../gobject/index.js";
-import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
+import * as Gdk from "../gdk/index.js";
 /**
  * A widget for displaying both trees and lists
  *
@@ -31,7 +31,7 @@ import { Widget } from "./widget.js";
  * - Bin window coordinates: Coordinates relative to the window that GtkTreeView renders to.
  *
  * - Tree coordinates: Coordinates relative to the entire scrollable area of GtkTreeView. These
- * coordinates start at (0, 0) for row 0 of the tree.
+ *   coordinates start at (0, 0) for row 0 of the tree.
  *
  * Several functions are available for converting between the different
  * coordinate systems.  The most common translations are between widget and bin
@@ -98,167 +98,10 @@ import { Widget } from "./widget.js";
  *
  * For the drop target location during DND, a subnode with name `dndtarget` is used.
  */
-const SIGNAL_META = {
-    "columns-changed": { params: [], returnType: { type: "undefined" } },
-    "cursor-changed": { params: [], returnType: { type: "undefined" } },
-    "expand-collapse-cursor-row": {
-        params: [{ type: "boolean" }, { type: "boolean" }, { type: "boolean" }],
-        returnType: { type: "boolean" },
-    },
-    "move-cursor": {
-        params: [
-            { type: "int", size: 32, unsigned: false },
-            { type: "int", size: 32, unsigned: false },
-            { type: "boolean" },
-            { type: "boolean" },
-        ],
-        returnType: { type: "boolean" },
-    },
-    "row-activated": {
-        params: [
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreePath",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_path_get_type",
-            },
-            { type: "gobject", borrowed: true },
-        ],
-        returnType: { type: "undefined" },
-    },
-    "row-collapsed": {
-        params: [
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreeIter",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_iter_get_type",
-            },
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreePath",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_path_get_type",
-            },
-        ],
-        returnType: { type: "undefined" },
-    },
-    "row-expanded": {
-        params: [
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreeIter",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_iter_get_type",
-            },
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreePath",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_path_get_type",
-            },
-        ],
-        returnType: { type: "undefined" },
-    },
-    "select-all": { params: [], returnType: { type: "boolean" } },
-    "select-cursor-parent": { params: [], returnType: { type: "boolean" } },
-    "select-cursor-row": {
-        params: [{ type: "boolean" }],
-        returnType: { type: "boolean" },
-    },
-    "start-interactive-search": { params: [], returnType: { type: "boolean" } },
-    "test-collapse-row": {
-        params: [
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreeIter",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_iter_get_type",
-            },
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreePath",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_path_get_type",
-            },
-        ],
-        returnType: { type: "boolean" },
-    },
-    "test-expand-row": {
-        params: [
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreeIter",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_iter_get_type",
-            },
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreePath",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_path_get_type",
-            },
-        ],
-        returnType: { type: "boolean" },
-    },
-    "toggle-cursor-row": { params: [], returnType: { type: "boolean" } },
-    "unselect-all": { params: [], returnType: { type: "boolean" } },
-    destroy: { params: [], returnType: { type: "undefined" } },
-    "direction-changed": {
-        params: [{ type: "int", size: 32, unsigned: false }],
-        returnType: { type: "undefined" },
-    },
-    hide: { params: [], returnType: { type: "undefined" } },
-    "keynav-failed": {
-        params: [{ type: "int", size: 32, unsigned: false }],
-        returnType: { type: "boolean" },
-    },
-    map: { params: [], returnType: { type: "undefined" } },
-    "mnemonic-activate": {
-        params: [{ type: "boolean" }],
-        returnType: { type: "boolean" },
-    },
-    "move-focus": {
-        params: [{ type: "int", size: 32, unsigned: false }],
-        returnType: { type: "undefined" },
-    },
-    "query-tooltip": {
-        params: [
-            { type: "int", size: 32, unsigned: false },
-            { type: "int", size: 32, unsigned: false },
-            { type: "boolean" },
-            { type: "gobject", borrowed: true },
-        ],
-        returnType: { type: "boolean" },
-    },
-    realize: { params: [], returnType: { type: "undefined" } },
-    show: { params: [], returnType: { type: "undefined" } },
-    "state-flags-changed": {
-        params: [{ type: "int", size: 32, unsigned: true }],
-        returnType: { type: "undefined" },
-    },
-    unmap: { params: [], returnType: { type: "undefined" } },
-    unrealize: { params: [], returnType: { type: "undefined" } },
-    notify: {
-        params: [{ type: "gparam", borrowed: true }],
-        returnType: { type: "undefined" },
-    },
-};
 export class TreeView extends Widget {
     static glibTypeName = "GtkTreeView";
     static objectType = "gobject";
-    /**
-     * Creates a new `GtkTreeView` widget.
-     */
+    /** Creates a new `GtkTreeView` widget. */
     constructor() {
         if (!isInstantiating) {
             setInstantiating(true);
@@ -267,7 +110,7 @@ export class TreeView extends Widget {
             setInstantiating(false);
             this.id = call("libgtk-4.so.1", "gtk_tree_view_new", [], {
                 type: "gobject",
-                borrowed: true,
+                ownership: "none",
             });
         }
         else {
@@ -275,69 +118,87 @@ export class TreeView extends Widget {
             super();
         }
     }
-    /**
-     * Creates a new `GtkTreeView` widget with the model initialized to `model`.
-     * @param model - the model.
-     */
-    static viewNewWithModel(model) {
+    /** Creates a new `GtkTreeView` widget with the model initialized to `model`. */
+    static newWithModel(model) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_new_with_model", [
             {
-                type: { type: "gobject", borrowed: true },
-                value: model?.id ?? model,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: model.id,
+                optional: false,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         return getNativeObject(ptr);
     }
     /**
      * Appends `column` to the list of columns. If `tree_view` has “fixed_height”
      * mode enabled, then `column` must have its “sizing” property set to be
      * GTK_TREE_VIEW_COLUMN_FIXED.
-     * @param column - The `GtkTreeViewColumn` to add.
      */
     appendColumn(column) {
         return call("libgtk-4.so.1", "gtk_tree_view_append_column", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: column?.id ?? column,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: column.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
-    /**
-     * Recursively collapses all visible, expanded nodes in `tree_view`.
-     */
+    /** Recursively collapses all visible, expanded nodes in `tree_view`. */
     collapseAll() {
         call("libgtk-4.so.1", "gtk_tree_view_collapse_all", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Collapses a row (hides its child rows, if they exist).
-     * @param path - path to a row in the `tree_view`
-     */
+    /** Collapses a row (hides its child rows, if they exist). */
     collapseRow(path) {
         return call("libgtk-4.so.1", "gtk_tree_view_collapse_row", [
             {
-                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",
+        });
     }
     /**
      * Resizes all columns to their optimal width. Only works after the
@@ -346,259 +207,367 @@ export class TreeView extends Widget {
     columnsAutosize() {
         call("libgtk-4.so.1", "gtk_tree_view_columns_autosize", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Converts bin_window coordinates to coordinates for the
      * tree (the full scrollable area of the tree).
-     * @param bx - X coordinate relative to bin_window
-     * @param by - Y coordinate relative to bin_window
-     * @param tx - return location for tree X coordinate
-     * @param ty - return location for tree Y coordinate
      */
     convertBinWindowToTreeCoords(bx, by, tx, ty) {
         call("libgtk-4.so.1", "gtk_tree_view_convert_bin_window_to_tree_coords", [
             {
-                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: bx,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: by,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: tx,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: ty,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Converts bin_window coordinates to widget relative coordinates.
-     * @param bx - bin_window X coordinate
-     * @param by - bin_window Y coordinate
-     * @param wx - return location for widget X coordinate
-     * @param wy - return location for widget Y coordinate
-     */
+    /** Converts bin_window coordinates to widget relative coordinates. */
     convertBinWindowToWidgetCoords(bx, by, wx, wy) {
         call("libgtk-4.so.1", "gtk_tree_view_convert_bin_window_to_widget_coords", [
             {
-                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: bx,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: by,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: wx,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: wy,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Converts tree coordinates (coordinates in full scrollable area of the tree)
      * to bin_window coordinates.
-     * @param tx - tree X coordinate
-     * @param ty - tree Y coordinate
-     * @param bx - return location for X coordinate relative to bin_window
-     * @param by - return location for Y coordinate relative to bin_window
      */
     convertTreeToBinWindowCoords(tx, ty, bx, by) {
         call("libgtk-4.so.1", "gtk_tree_view_convert_tree_to_bin_window_coords", [
             {
-                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: tx,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: ty,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: bx,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: by,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Converts tree coordinates (coordinates in full scrollable area of the tree)
      * to widget coordinates.
-     * @param tx - X coordinate relative to the tree
-     * @param ty - Y coordinate relative to the tree
-     * @param wx - return location for widget X coordinate
-     * @param wy - return location for widget Y coordinate
      */
     convertTreeToWidgetCoords(tx, ty, wx, wy) {
         call("libgtk-4.so.1", "gtk_tree_view_convert_tree_to_widget_coords", [
             {
-                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: tx,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: ty,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: wx,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: wy,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Converts widget coordinates to coordinates for the bin_window.
-     * @param wx - X coordinate relative to the widget
-     * @param wy - Y coordinate relative to the widget
-     * @param bx - return location for bin_window X coordinate
-     * @param by - return location for bin_window Y coordinate
-     */
+    /** Converts widget coordinates to coordinates for the bin_window. */
     convertWidgetToBinWindowCoords(wx, wy, bx, by) {
         call("libgtk-4.so.1", "gtk_tree_view_convert_widget_to_bin_window_coords", [
             {
-                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: wx,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: wy,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: bx,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: by,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Converts widget coordinates to coordinates for the
      * tree (the full scrollable area of the tree).
-     * @param wx - X coordinate relative to the widget
-     * @param wy - Y coordinate relative to the widget
-     * @param tx - return location for tree X coordinate
-     * @param ty - return location for tree Y coordinate
      */
     convertWidgetToTreeCoords(wx, wy, tx, ty) {
         call("libgtk-4.so.1", "gtk_tree_view_convert_widget_to_tree_coords", [
             {
-                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: wx,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: wy,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: tx,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: ty,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Creates a `cairo_surface_t` representation of the row at `path`.
      * This image is used for a drag icon.
-     * @param path - a `GtkTreePath` in `tree_view`
      */
     createRowDragIcon(path) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_create_row_drag_icon", [
             {
-                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, Gdk.Paintable);
@@ -606,135 +575,165 @@ export class TreeView extends Widget {
     /**
      * Turns `tree_view` into a drop destination for automatic DND. Calling
      * this method sets `GtkTreeView`:reorderable to %FALSE.
-     * @param formats - the target formats that the drag will support
-     * @param actions - the bitmask of possible actions for a drag from this
      */
     enableModelDragDest(formats, actions) {
         call("libgtk-4.so.1", "gtk_tree_view_enable_model_drag_dest", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkContentFormats",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_content_formats_get_type",
                 },
-                value: formats?.id ?? formats,
+                value: formats.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: actions,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Turns `tree_view` into a drag source for automatic DND. Calling this
      * method sets `GtkTreeView`:reorderable to %FALSE.
-     * @param startButtonMask - Mask of allowed buttons to start drag
-     * @param formats - the target formats that the drag will support
-     * @param actions - the bitmask of possible actions for a drag from this
      */
     enableModelDragSource(startButtonMask, formats, actions) {
         call("libgtk-4.so.1", "gtk_tree_view_enable_model_drag_source", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: startButtonMask,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkContentFormats",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_content_formats_get_type",
                 },
-                value: formats?.id ?? formats,
+                value: formats.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: actions,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Recursively expands all nodes in the `tree_view`.
-     */
+    /** Recursively expands all nodes in the `tree_view`. */
     expandAll() {
         call("libgtk-4.so.1", "gtk_tree_view_expand_all", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Opens the row so its children are visible.
-     * @param path - path to a row
-     * @param openAll - whether to recursively expand, or just expand immediate children
-     */
+    /** Opens the row so its children are visible. */
     expandRow(path, openAll) {
         return call("libgtk-4.so.1", "gtk_tree_view_expand_row", [
             {
-                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: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: openAll,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Expands the row at `path`. This will also expand all parent rows of
      * `path` as necessary.
-     * @param path - path to a row.
      */
     expandToPath(path) {
         call("libgtk-4.so.1", "gtk_tree_view_expand_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: path?.id ?? path,
+                value: path.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Gets the setting set by gtk_tree_view_set_activate_on_single_click().
-     */
+    /** Gets the setting set by gtk_tree_view_set_activate_on_single_click(). */
     getActivateOnSingleClick() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_activate_on_single_click", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Fills the bounding rectangle in bin_window coordinates for the cell at the
@@ -746,43 +745,48 @@ export class TreeView extends Widget {
      * areas tile to cover the entire bin window.  Contrast with the `cell_area`,
      * returned by gtk_tree_view_get_cell_area(), which returns only the cell
      * itself, excluding surrounding borders and the tree expander area.
-     * @param path - a `GtkTreePath` for the row, or %NULL to get only horizontal coordinates
-     * @param column - a `GtkTreeViewColumn` for the column, or %NULL to get only vertical coordinates
-     * @param rect - rectangle to fill with cell background rect
      */
     getBackgroundArea(rect, path, column) {
         call("libgtk-4.so.1", "gtk_tree_view_get_background_area", [
             {
-                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,
                 optional: true,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: column?.id ?? column,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: column?.id,
                 optional: true,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRectangle",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rectangle_get_type",
                 },
-                value: rect?.id ?? rect,
+                value: rect.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Fills the bounding rectangle in bin_window coordinates for the cell at the
@@ -794,59 +798,71 @@ export class TreeView extends Widget {
      * returned rectangle is equivalent to the `cell_area` passed to
      * gtk_cell_renderer_render().  This function is only valid if `tree_view` is
      * realized.
-     * @param path - a `GtkTreePath` for the row, or %NULL to get only horizontal coordinates
-     * @param column - a `GtkTreeViewColumn` for the column, or %NULL to get only vertical coordinates
-     * @param rect - rectangle to fill with cell rect
      */
     getCellArea(rect, path, column) {
         call("libgtk-4.so.1", "gtk_tree_view_get_cell_area", [
             {
-                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,
                 optional: true,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: column?.id ?? column,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: column?.id,
                 optional: true,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRectangle",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rectangle_get_type",
                 },
-                value: rect?.id ?? rect,
+                value: rect.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Gets the `GtkTreeViewColumn` at the given position in the #tree_view.
-     * @param n - The position of the column, counting from 0.
-     */
+    /** Gets the `GtkTreeViewColumn` at the given position in the #tree_view. */
     getColumn(n) {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_get_column", [
             {
-                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: n,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
@@ -856,18 +872,24 @@ export class TreeView extends Widget {
      * The returned list must be freed with g_list_free ().
      */
     getColumns() {
-        const ptrs = call("libgtk-4.so.1", "gtk_tree_view_get_columns", [
+        const arr = call("libgtk-4.so.1", "gtk_tree_view_get_columns", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
         ], {
             type: "array",
-            itemType: { type: "gobject", borrowed: true },
+            itemType: {
+                type: "gobject",
+                ownership: "none",
+            },
             listType: "glist",
-            borrowed: true,
+            ownership: "none",
         });
-        return ptrs.map((ptr) => getNativeObject(ptr));
+        return arr.map((item) => getNativeObject(item));
     }
     /**
      * Fills in `path` and `focus_column` with the current path and focus column.  If
@@ -876,13 +898,14 @@ export class TreeView extends Widget {
      *
      * The returned `GtkTreePath` must be freed with gtk_tree_path_free() when
      * you are done with it.
-     * @param path - A pointer to be
-     * @param focusColumn - A
      */
-    treeViewGetCursor(path, focusColumn) {
+    TreeViewGetCursor(path, focusColumn) {
         call("libgtk-4.so.1", "gtk_tree_view_get_cursor", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
@@ -890,6 +913,7 @@ export class TreeView extends Widget {
                     type: "ref",
                     innerType: {
                         type: "boxed",
+                        ownership: "full",
                         innerType: "GtkTreePath",
                         lib: "libgtk-4.so.1",
                         getTypeFn: "gtk_tree_path_get_type",
@@ -899,11 +923,19 @@ export class TreeView extends Widget {
                 optional: true,
             },
             {
-                type: { type: "ref", innerType: { type: "gobject" } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                },
                 value: focusColumn,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
         if (path)
             path.value = getNativeObject(path.value, TreePath);
         if (focusColumn)
@@ -914,23 +946,30 @@ export class TreeView extends Widget {
      * `drag_y` are expected to be in widget coordinates.  This function is only
      * meaningful if `tree_view` is realized.  Therefore this function will always
      * return %FALSE if `tree_view` is not realized or does not have a model.
-     * @param dragX - the position to determine the destination row for
-     * @param dragY - the position to determine the destination row for
-     * @param path - Return location for the path of
-     * @param pos - Return location for the drop position, or
      */
     getDestRowAtPos(dragX, dragY, path, pos) {
         const result = call("libgtk-4.so.1", "gtk_tree_view_get_dest_row_at_pos", [
             {
-                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: dragX,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: dragY,
             },
             {
@@ -938,6 +977,7 @@ export class TreeView extends Widget {
                     type: "ref",
                     innerType: {
                         type: "boxed",
+                        ownership: "full",
                         innerType: "GtkTreePath",
                         lib: "libgtk-4.so.1",
                         getTypeFn: "gtk_tree_path_get_type",
@@ -949,25 +989,30 @@ export class TreeView extends Widget {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: pos,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
         if (path)
             path.value = getNativeObject(path.value, TreePath);
         return result;
     }
-    /**
-     * Gets information about the row that is highlighted for feedback.
-     * @param path - Return location for the path of the highlighted row
-     * @param pos - Return location for the drop position
-     */
+    /** Gets information about the row that is highlighted for feedback. */
     getDragDestRow(path, pos) {
         call("libgtk-4.so.1", "gtk_tree_view_get_drag_dest_row", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
@@ -975,6 +1020,7 @@ export class TreeView extends Widget {
                     type: "ref",
                     innerType: {
                         type: "boxed",
+                        ownership: "full",
                         innerType: "GtkTreePath",
                         lib: "libgtk-4.so.1",
                         getTypeFn: "gtk_tree_path_get_type",
@@ -986,12 +1032,18 @@ export class TreeView extends Widget {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: pos,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
         if (path)
             path.value = getNativeObject(path.value, TreePath);
     }
@@ -1002,21 +1054,29 @@ export class TreeView extends Widget {
     getEnableSearch() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_enable_search", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Returns whether or not tree lines are drawn in `tree_view`.
-     */
+    /** Returns whether or not tree lines are drawn in `tree_view`. */
     getEnableTreeLines() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_enable_tree_lines", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Returns the column that is the current expander column,
@@ -1026,79 +1086,105 @@ export class TreeView extends Widget {
     getExpanderColumn() {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_get_expander_column", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
     }
-    /**
-     * Returns whether fixed height mode is turned on for `tree_view`.
-     */
+    /** Returns whether fixed height mode is turned on for `tree_view`. */
     getFixedHeightMode() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_fixed_height_mode", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Returns which grid lines are enabled in `tree_view`.
-     */
+    /** Returns which grid lines are enabled in `tree_view`. */
     getGridLines() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_grid_lines", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
-    /**
-     * Returns whether all header columns are clickable.
-     */
+    /** Returns whether all header columns are clickable. */
     getHeadersClickable() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_headers_clickable", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Returns %TRUE if the headers on the `tree_view` are visible.
-     */
+    /** Returns %TRUE if the headers on the `tree_view` are visible. */
     getHeadersVisible() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_headers_visible", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Returns whether hover expansion mode is turned on for `tree_view`.
-     */
+    /** Returns whether hover expansion mode is turned on for `tree_view`. */
     getHoverExpand() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_hover_expand", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Returns whether hover selection mode is turned on for `tree_view`.
-     */
+    /** Returns whether hover selection mode is turned on for `tree_view`. */
     getHoverSelection() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_hover_selection", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Returns the amount, in pixels, of extra indentation for child levels
@@ -1107,10 +1193,17 @@ export class TreeView extends Widget {
     getLevelIndentation() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_level_indentation", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Returns the model the `GtkTreeView` is based on.  Returns %NULL if the
@@ -1119,24 +1212,35 @@ export class TreeView extends Widget {
     getModel() {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_get_model", [
             {
-                type: { type: "gobject" },
-                value: this.id,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr, TreeModel);
     }
-    /**
-     * Queries the number of columns in the given `tree_view`.
-     */
+    /** Queries the number of columns in the given `tree_view`. */
     getNColumns() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_n_columns", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: true });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
     }
     /**
      * Finds the path at the point (`x`, `y`), relative to bin_window coordinates.
@@ -1155,25 +1259,30 @@ export class TreeView extends Widget {
      * For converting widget coordinates (eg. the ones you get from
      * GtkWidget::query-tooltip), please see
      * gtk_tree_view_convert_widget_to_bin_window_coords().
-     * @param x - The x position to be identified (relative to bin_window).
-     * @param y - The y position to be identified (relative to bin_window).
-     * @param path - A pointer to a `GtkTreePath`
-     * @param column - A pointer to
-     * @param cellX - A pointer where the X coordinate
-     * @param cellY - A pointer where the Y coordinate
      */
     getPathAtPos(x, y, path, column, cellX, cellY) {
         const result = call("libgtk-4.so.1", "gtk_tree_view_get_path_at_pos", [
             {
-                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: x,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: y,
             },
             {
@@ -1181,6 +1290,7 @@ export class TreeView extends Widget {
                     type: "ref",
                     innerType: {
                         type: "boxed",
+                        ownership: "full",
                         innerType: "GtkTreePath",
                         lib: "libgtk-4.so.1",
                         getTypeFn: "gtk_tree_path_get_type",
@@ -1190,14 +1300,24 @@ export class TreeView extends Widget {
                 optional: true,
             },
             {
-                type: { type: "ref", innerType: { type: "gobject" } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                },
                 value: column,
                 optional: true,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: cellX,
                 optional: true,
@@ -1205,12 +1325,18 @@ export class TreeView extends Widget {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: cellY,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
         if (path)
             path.value = getNativeObject(path.value, TreePath);
         if (column)
@@ -1224,10 +1350,15 @@ export class TreeView extends Widget {
     getReorderable() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_reorderable", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Returns whether rubber banding is turned on for `tree_view`.  If the
@@ -1237,21 +1368,31 @@ export class TreeView extends Widget {
     getRubberBanding() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_rubber_banding", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Gets the column searched on by the interactive search code.
-     */
+    /** Gets the column searched on by the interactive search code. */
     getSearchColumn() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_search_column", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Returns the `GtkEntry` which is currently in use as interactive search
@@ -1261,36 +1402,49 @@ export class TreeView extends Widget {
     getSearchEntry() {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_get_search_entry", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr, Editable);
     }
-    /**
-     * Gets the `GtkTreeSelection` associated with `tree_view`.
-     */
+    /** Gets the `GtkTreeSelection` associated with `tree_view`. */
     getSelection() {
         const ptr = call("libgtk-4.so.1", "gtk_tree_view_get_selection", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         return getNativeObject(ptr);
     }
-    /**
-     * Returns whether or not expanders are drawn in `tree_view`.
-     */
+    /** Returns whether or not expanders are drawn in `tree_view`. */
     getShowExpanders() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_show_expanders", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Returns the column of `tree_view`’s model which is being used for
@@ -1299,10 +1453,17 @@ export class TreeView extends Widget {
     getTooltipColumn() {
         return call("libgtk-4.so.1", "gtk_tree_view_get_tooltip_column", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * This function is supposed to be used in a ::query-tooltip
@@ -1316,33 +1477,46 @@ export class TreeView extends Widget {
      * `model`, `path` and `iter` which have been provided will be set to point to
      * that row and the corresponding model. `x` and `y` will always be converted
      * to be relative to `tree_view`’s bin_window if `keyboard_tooltip` is %FALSE.
-     * @param x - the x coordinate (relative to widget coordinates)
-     * @param y - the y coordinate (relative to widget coordinates)
-     * @param keyboardTip - whether this is a keyboard tooltip or not
-     * @param model - a pointer to
-     * @param path - a pointer to receive a `GtkTreePath`
-     * @param iter - a pointer to receive a `GtkTreeIter`
      */
     getTooltipContext(x, y, keyboardTip, model, path, iter) {
         const result = call("libgtk-4.so.1", "gtk_tree_view_get_tooltip_context", [
             {
-                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: x,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: y,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: keyboardTip,
             },
             {
-                type: { type: "ref", innerType: { type: "gobject" } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                },
                 value: model,
                 optional: true,
             },
@@ -1351,6 +1525,7 @@ export class TreeView extends Widget {
                     type: "ref",
                     innerType: {
                         type: "boxed",
+                        ownership: "full",
                         innerType: "GtkTreePath",
                         lib: "libgtk-4.so.1",
                         getTypeFn: "gtk_tree_path_get_type",
@@ -1362,15 +1537,17 @@ export class TreeView extends Widget {
             {
                 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: "boolean" });
+        ], {
+            type: "boolean",
+        });
         if (model)
             model.value = getNativeObject(model.value);
         if (path)
@@ -1382,13 +1559,14 @@ export class TreeView extends Widget {
      * Note that there may be invisible paths in between.
      *
      * The paths should be freed with gtk_tree_path_free() after use.
-     * @param startPath - Return location for start of region
-     * @param endPath - Return location for end of region
      */
     getVisibleRange(startPath, endPath) {
         const result = call("libgtk-4.so.1", "gtk_tree_view_get_visible_range", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
@@ -1396,6 +1574,7 @@ export class TreeView extends Widget {
                     type: "ref",
                     innerType: {
                         type: "boxed",
+                        ownership: "full",
                         innerType: "GtkTreePath",
                         lib: "libgtk-4.so.1",
                         getTypeFn: "gtk_tree_path_get_type",
@@ -1409,6 +1588,7 @@ export class TreeView extends Widget {
                     type: "ref",
                     innerType: {
                         type: "boxed",
+                        ownership: "full",
                         innerType: "GtkTreePath",
                         lib: "libgtk-4.so.1",
                         getTypeFn: "gtk_tree_path_get_type",
@@ -1417,7 +1597,9 @@ export class TreeView extends Widget {
                 value: endPath,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
         if (startPath)
             startPath.value = getNativeObject(startPath.value, TreePath);
         if (endPath)
@@ -1430,49 +1612,65 @@ export class TreeView extends Widget {
      * gtk_tree_view_convert_tree_to_bin_window_coords().
      * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
      * scrollable area of the tree.
-     * @param visibleRect - rectangle to fill
      */
     getVisibleRect(visibleRect) {
         call("libgtk-4.so.1", "gtk_tree_view_get_visible_rect", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRectangle",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rectangle_get_type",
                 },
-                value: visibleRect?.id ?? visibleRect,
+                value: visibleRect.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * This inserts the `column` into the `tree_view` at `position`.  If `position` is
      * -1, then the column is inserted at the end. If `tree_view` has
      * “fixed_height” mode enabled, then `column` must have its “sizing” property
      * set to be GTK_TREE_VIEW_COLUMN_FIXED.
-     * @param column - The `GtkTreeViewColumn` to be inserted.
-     * @param position - The position to insert `column` in.
      */
     insertColumn(column, position) {
         return call("libgtk-4.so.1", "gtk_tree_view_insert_column", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: column?.id ?? column,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: column.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: position,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Determine whether the point (`x`, `y`) in `tree_view` is blank, that is no
@@ -1492,25 +1690,30 @@ export class TreeView extends Widget {
      * The `path`, `column`, `cell_x` and `cell_y` arguments will be filled in
      * likewise as for gtk_tree_view_get_path_at_pos().  Please see
      * gtk_tree_view_get_path_at_pos() for more information.
-     * @param x - The x position to be identified (relative to bin_window)
-     * @param y - The y position to be identified (relative to bin_window)
-     * @param path - A pointer to a `GtkTreePath` pointer to
-     * @param column - A pointer to a
-     * @param cellX - A pointer where the X coordinate relative to the
-     * @param cellY - A pointer where the Y coordinate relative to the
      */
     isBlankAtPos(x, y, path, column, cellX, cellY) {
         const result = call("libgtk-4.so.1", "gtk_tree_view_is_blank_at_pos", [
             {
-                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: x,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: y,
             },
             {
@@ -1518,6 +1721,7 @@ export class TreeView extends Widget {
                     type: "ref",
                     innerType: {
                         type: "boxed",
+                        ownership: "full",
                         innerType: "GtkTreePath",
                         lib: "libgtk-4.so.1",
                         getTypeFn: "gtk_tree_path_get_type",
@@ -1527,14 +1731,24 @@ export class TreeView extends Widget {
                 optional: true,
             },
             {
-                type: { type: "ref", innerType: { type: "gobject" } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                },
                 value: column,
                 optional: true,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: cellX,
                 optional: true,
@@ -1542,12 +1756,18 @@ export class TreeView extends Widget {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: cellY,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
         if (path)
             path.value = getNativeObject(path.value, TreePath);
         if (column)
@@ -1561,99 +1781,126 @@ export class TreeView extends Widget {
     isRubberBandingActive() {
         return call("libgtk-4.so.1", "gtk_tree_view_is_rubber_banding_active", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `column` to be after to `base_column`.  If `base_column` is %NULL, then
      * `column` is placed in the first position.
-     * @param column - The `GtkTreeViewColumn` to be moved.
-     * @param baseColumn - The `GtkTreeViewColumn` to be moved relative to
      */
     moveColumnAfter(column, baseColumn) {
         call("libgtk-4.so.1", "gtk_tree_view_move_column_after", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: column?.id ?? column,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: column.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: baseColumn?.id ?? baseColumn,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: baseColumn?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Removes `column` from `tree_view`.
-     * @param column - The `GtkTreeViewColumn` to remove.
-     */
+    /** Removes `column` from `tree_view`. */
     removeColumn(column) {
         return call("libgtk-4.so.1", "gtk_tree_view_remove_column", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: column?.id ?? column,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: column.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
-    /**
-     * Activates the cell determined by `path` and `column`.
-     * @param path - The `GtkTreePath` to be activated.
-     * @param column - The `GtkTreeViewColumn` to be activated.
-     */
+    /** Activates the cell determined by `path` and `column`. */
     rowActivated(path, column) {
         call("libgtk-4.so.1", "gtk_tree_view_row_activated", [
             {
-                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: "gobject", borrowed: true },
-                value: column?.id ?? column,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: column?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Returns %TRUE if the node pointed to by `path` is expanded in `tree_view`.
-     * @param path - A `GtkTreePath` to test expansion state.
-     */
+    /** Returns %TRUE if the node pointed to by `path` is expanded in `tree_view`. */
     rowExpanded(path) {
         return call("libgtk-4.so.1", "gtk_tree_view_row_expanded", [
             {
-                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",
+        });
     }
     /**
      * Moves the alignments of `tree_view` to the position specified by `column` and
@@ -1672,47 +1919,58 @@ export class TreeView extends Widget {
      * This function only works if the model is set, and `path` is a valid row on the
      * model.  If the model changes before the `tree_view` is realized, the centered
      * path will be modified to reflect this change.
-     * @param path - The path of the row to move to
-     * @param column - The `GtkTreeViewColumn` to move horizontally to
-     * @param useAlign - whether to use alignment arguments, or %FALSE.
-     * @param rowAlign - The vertical alignment of the row specified by `path`.
-     * @param colAlign - The horizontal alignment of the column specified by `column`.
      */
     scrollToCell(useAlign, rowAlign, colAlign, path, column) {
         call("libgtk-4.so.1", "gtk_tree_view_scroll_to_cell", [
             {
-                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,
                 optional: true,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: column?.id ?? column,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: column?.id,
                 optional: true,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: useAlign,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: rowAlign,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: colAlign,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Scrolls the tree view such that the top-left corner of the visible
@@ -1722,41 +1980,58 @@ export class TreeView extends Widget {
      * using gtk_tree_view_scroll_to_cell().
      *
      * If either `tree_x` or `tree_y` are -1, then that direction isn’t scrolled.
-     * @param treeX - X coordinate of new top-left pixel of visible area, or -1
-     * @param treeY - Y coordinate of new top-left pixel of visible area, or -1
      */
     scrollToPoint(treeX, treeY) {
         call("libgtk-4.so.1", "gtk_tree_view_scroll_to_point", [
             {
-                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: treeX,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: treeY,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Cause the `GtkTreeView`::row-activated signal to be emitted
      * on a single click instead of a double click.
-     * @param single - %TRUE to emit row-activated on a single click
      */
     setActivateOnSingleClick(single) {
         call("libgtk-4.so.1", "gtk_tree_view_set_activate_on_single_click", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: single,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the current keyboard focus to be at `path`, and selects it.  This is
@@ -1770,36 +2045,43 @@ export class TreeView extends Widget {
      *
      * If `path` is invalid for `model`, the current cursor (if any) will be unset
      * and the function will return without failing.
-     * @param path - A `GtkTreePath`
-     * @param focusColumn - A `GtkTreeViewColumn`
-     * @param startEditing - %TRUE if the specified cell should start being edited.
      */
-    treeViewSetCursor(path, startEditing, focusColumn) {
+    TreeViewSetCursor(path, startEditing, focusColumn) {
         call("libgtk-4.so.1", "gtk_tree_view_set_cursor", [
             {
-                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: "gobject", borrowed: true },
-                value: focusColumn?.id ?? focusColumn,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: focusColumn?.id,
                 optional: true,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: startEditing,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the current keyboard focus to be at `path`, and selects it.  This is
@@ -1816,71 +2098,87 @@ export class TreeView extends Widget {
      *
      * If `path` is invalid for `model`, the current cursor (if any) will be unset
      * and the function will return without failing.
-     * @param path - A `GtkTreePath`
-     * @param focusColumn - A `GtkTreeViewColumn`
-     * @param focusCell - A `GtkCellRenderer`
-     * @param startEditing - %TRUE if the specified cell should start being edited.
      */
     setCursorOnCell(path, startEditing, focusColumn, focusCell) {
         call("libgtk-4.so.1", "gtk_tree_view_set_cursor_on_cell", [
             {
-                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: "gobject", borrowed: true },
-                value: focusColumn?.id ?? focusColumn,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: focusColumn?.id,
                 optional: true,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: focusCell?.id ?? focusCell,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: focusCell?.id,
                 optional: true,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: startEditing,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the row that is highlighted for feedback.
      * If `path` is %NULL, an existing highlight is removed.
-     * @param path - The path of the row to highlight
-     * @param pos - Specifies whether to drop before, after or into the row
      */
     setDragDestRow(pos, path) {
         call("libgtk-4.so.1", "gtk_tree_view_set_drag_dest_row", [
             {
-                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,
                 optional: true,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: pos,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * If `enable_search` is set, then the user can type in text to search through
@@ -1888,36 +2186,48 @@ export class TreeView extends Widget {
      *
      * Note that even if this is %FALSE, the user can still initiate a search
      * using the “start-interactive-search” key binding.
-     * @param enableSearch - %TRUE, if the user can search interactively
      */
     setEnableSearch(enableSearch) {
         call("libgtk-4.so.1", "gtk_tree_view_set_enable_search", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: enableSearch,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets whether to draw lines interconnecting the expanders in `tree_view`.
      * This does not have any visible effects for lists.
-     * @param enabled - %TRUE to enable tree line drawing, %FALSE otherwise.
      */
     setEnableTreeLines(enabled) {
         call("libgtk-4.so.1", "gtk_tree_view_set_enable_tree_lines", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: enabled,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the column to draw the expander arrow at. It must be in `tree_view`.
@@ -1926,20 +2236,27 @@ export class TreeView extends Widget {
      *
      * If you do not want expander arrow to appear in your tree, set the
      * expander column to a hidden column.
-     * @param column - %NULL, or the column to draw the expander arrow at.
      */
     setExpanderColumn(column) {
         call("libgtk-4.so.1", "gtk_tree_view_set_expander_column", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: column?.id ?? column,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: column?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Enables or disables the fixed height mode of `tree_view`.
@@ -1947,104 +2264,136 @@ export class TreeView extends Widget {
      * rows have the same height.
      * Only enable this option if all rows are the same height and all
      * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
-     * @param enable - %TRUE to enable fixed height mode
      */
     setFixedHeightMode(enable) {
         call("libgtk-4.so.1", "gtk_tree_view_set_fixed_height_mode", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: enable,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Sets which grid lines to draw in `tree_view`.
-     * @param gridLines - a `GtkTreeView`GridLines value indicating which grid lines to
-     */
+    /** Sets which grid lines to draw in `tree_view`. */
     setGridLines(gridLines) {
         call("libgtk-4.so.1", "gtk_tree_view_set_grid_lines", [
             {
-                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: gridLines,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Allow the column title buttons to be clicked.
-     * @param setting - %TRUE if the columns are clickable.
-     */
+    /** Allow the column title buttons to be clicked. */
     setHeadersClickable(setting) {
         call("libgtk-4.so.1", "gtk_tree_view_set_headers_clickable", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: setting,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Sets the visibility state of the headers.
-     * @param headersVisible - %TRUE if the headers are visible
-     */
+    /** Sets the visibility state of the headers. */
     setHeadersVisible(headersVisible) {
         call("libgtk-4.so.1", "gtk_tree_view_set_headers_visible", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: headersVisible,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Enables or disables the hover expansion mode of `tree_view`.
      * Hover expansion makes rows expand or collapse if the pointer
      * moves over them.
-     * @param expand - %TRUE to enable hover selection mode
      */
     setHoverExpand(expand) {
         call("libgtk-4.so.1", "gtk_tree_view_set_hover_expand", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: expand,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Enables or disables the hover selection mode of `tree_view`.
      * Hover selection makes the selected row follow the pointer.
      * Currently, this works only for the selection modes
      * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
-     * @param hover - %TRUE to enable hover selection mode
      */
     setHoverSelection(hover) {
         call("libgtk-4.so.1", "gtk_tree_view_set_hover_selection", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: hover,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the amount of extra indentation for child levels to use in `tree_view`
@@ -2052,38 +2401,53 @@ export class TreeView extends Widget {
      * pixels, a value of 0 disables this feature and in this case only the default
      * indentation will be used.
      * This does not have any visible effects for lists.
-     * @param indentation - the amount, in pixels, of extra indentation in `tree_view`.
      */
     setLevelIndentation(indentation) {
         call("libgtk-4.so.1", "gtk_tree_view_set_level_indentation", [
             {
-                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: indentation,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the model for a `GtkTreeView`.  If the `tree_view` already has a model
      * set, it will remove it before setting the new model.  If `model` is %NULL,
      * then it will unset the old model.
-     * @param model - The model.
      */
     setModel(model) {
         call("libgtk-4.so.1", "gtk_tree_view_set_model", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: model?.id ?? model,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: model?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * This function is a convenience function to allow you to reorder
@@ -2100,37 +2464,49 @@ export class TreeView extends Widget {
      * This function does not give you any degree of control over the order -- any
      * reordering is allowed.  If more control is needed, you should probably
      * handle drag and drop manually.
-     * @param reorderable - %TRUE, if the tree can be reordered.
      */
     setReorderable(reorderable) {
         call("libgtk-4.so.1", "gtk_tree_view_set_reorderable", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: reorderable,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Enables or disables rubber banding in `tree_view`.  If the selection mode
      * is %GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
      * multiple rows by dragging the mouse.
-     * @param enable - %TRUE to enable rubber banding
      */
     setRubberBanding(enable) {
         call("libgtk-4.so.1", "gtk_tree_view_set_rubber_banding", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: enable,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets `column` as the column where the interactive search code should
@@ -2142,19 +2518,27 @@ export class TreeView extends Widget {
      *
      * Note that `column` refers to a column of the current model. The search
      * column is reset to -1 when the model is changed.
-     * @param column - the column of the model to search in, or -1 to disable searching
      */
     setSearchColumn(column) {
         call("libgtk-4.so.1", "gtk_tree_view_set_search_column", [
             {
-                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: column,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the entry which the interactive search code will use for this
@@ -2162,20 +2546,27 @@ export class TreeView extends Widget {
      * in our interface at all time at a fixed position.  Passing %NULL for
      * `entry` will make the interactive search code use the built-in popup
      * entry again.
-     * @param entry - the entry the interactive search code of `tree_view` should use
      */
     setSearchEntry(entry) {
         call("libgtk-4.so.1", "gtk_tree_view_set_search_entry", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: entry?.id ?? entry,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: entry?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets whether to draw and enable expanders and indent child rows in
@@ -2185,19 +2576,25 @@ export class TreeView extends Widget {
      * can set a custom indentation in this case using
      * gtk_tree_view_set_level_indentation().
      * This does not have any visible effects for lists.
-     * @param enabled - %TRUE to enable expander drawing, %FALSE otherwise.
      */
     setShowExpanders(enabled) {
         call("libgtk-4.so.1", "gtk_tree_view_set_show_expanders", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: enabled,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the tip area of `tooltip` to the area `path`, `column` and `cell` have
@@ -2211,43 +2608,53 @@ export class TreeView extends Widget {
      * mouse cursor for this function to operate correctly.
      *
      * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
-     * @param tooltip - a `GtkTooltip`
-     * @param path - a `GtkTreePath`
-     * @param column - a `GtkTreeViewColumn`
-     * @param cell - a `GtkCellRenderer`
      */
     setTooltipCell(tooltip, path, column, cell) {
         call("libgtk-4.so.1", "gtk_tree_view_set_tooltip_cell", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: tooltip?.id ?? tooltip,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: tooltip.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,
                 optional: true,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: column?.id ?? column,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: column?.id,
                 optional: true,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cell?.id ?? cell,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cell?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * If you only plan to have simple (text-only) tooltips on full rows, you
@@ -2260,48 +2667,62 @@ export class TreeView extends Widget {
      *
      * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
      * so &, <, etc have to be escaped in the text.
-     * @param column - an integer, which is a valid column number for `tree_view`’s model
      */
     setTooltipColumn(column) {
         call("libgtk-4.so.1", "gtk_tree_view_set_tooltip_column", [
             {
-                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: column,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the tip area of `tooltip` to be the area covered by the row at `path`.
      * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
      * See also gtk_tooltip_set_tip_area().
-     * @param tooltip - a `GtkTooltip`
-     * @param path - a `GtkTreePath`
      */
     setTooltipRow(tooltip, path) {
         call("libgtk-4.so.1", "gtk_tree_view_set_tooltip_row", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: tooltip?.id ?? tooltip,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: tooltip.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",
+        });
     }
     /**
      * Undoes the effect of
@@ -2311,10 +2732,15 @@ export class TreeView extends Widget {
     unsetRowsDragDest() {
         call("libgtk-4.so.1", "gtk_tree_view_unset_rows_drag_dest", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Undoes the effect of
@@ -2324,10 +2750,15 @@ export class TreeView extends Widget {
     unsetRowsDragSource() {
         call("libgtk-4.so.1", "gtk_tree_view_unset_rows_drag_source", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Returns the size of a non-scrolling border around the
@@ -2336,183 +2767,627 @@ export class TreeView extends Widget {
      * An example for this would be treeview headers. GTK can use
      * this information to display overlaid graphics, like the
      * overshoot indication, at the right position.
-     * @param border - return location for the results
      */
     getBorder(border) {
         return call("libgtk-4.so.1", "gtk_scrollable_get_border", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkBorder",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_border_get_type",
                 },
-                value: border?.id ?? border,
+                value: border.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Retrieves the `GtkAdjustment` used for horizontal scrolling.
-     */
+    /** Retrieves the `GtkAdjustment` used for horizontal scrolling. */
     getHadjustment() {
         const ptr = call("libgtk-4.so.1", "gtk_scrollable_get_hadjustment", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
     }
-    /**
-     * Gets the horizontal `GtkScrollablePolicy`.
-     */
+    /** Gets the horizontal `GtkScrollablePolicy`. */
     getHscrollPolicy() {
         return call("libgtk-4.so.1", "gtk_scrollable_get_hscroll_policy", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
-    /**
-     * Retrieves the `GtkAdjustment` used for vertical scrolling.
-     */
+    /** Retrieves the `GtkAdjustment` used for vertical scrolling. */
     getVadjustment() {
         const ptr = call("libgtk-4.so.1", "gtk_scrollable_get_vadjustment", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
     }
-    /**
-     * Gets the vertical `GtkScrollablePolicy`.
-     */
+    /** Gets the vertical `GtkScrollablePolicy`. */
     getVscrollPolicy() {
         return call("libgtk-4.so.1", "gtk_scrollable_get_vscroll_policy", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
-    /**
-     * Sets the horizontal adjustment of the `GtkScrollable`.
-     * @param hadjustment - a `GtkAdjustment`
-     */
+    /** Sets the horizontal adjustment of the `GtkScrollable`. */
     setHadjustment(hadjustment) {
         call("libgtk-4.so.1", "gtk_scrollable_set_hadjustment", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: hadjustment?.id ?? hadjustment,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: hadjustment?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the `GtkScrollablePolicy`.
      *
      * The policy determines whether horizontal scrolling should start
      * below the minimum width or below the natural width.
-     * @param policy - the horizontal `GtkScrollablePolicy`
      */
     setHscrollPolicy(policy) {
         call("libgtk-4.so.1", "gtk_scrollable_set_hscroll_policy", [
             {
-                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: policy,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Sets the vertical adjustment of the `GtkScrollable`.
-     * @param vadjustment - a `GtkAdjustment`
-     */
+    /** Sets the vertical adjustment of the `GtkScrollable`. */
     setVadjustment(vadjustment) {
         call("libgtk-4.so.1", "gtk_scrollable_set_vadjustment", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: vadjustment?.id ?? vadjustment,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: vadjustment?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the `GtkScrollablePolicy`.
      *
      * The policy determines whether vertical scrolling should start
      * below the minimum height or below the natural height.
-     * @param policy - the vertical `GtkScrollablePolicy`
      */
     setVscrollPolicy(policy) {
         call("libgtk-4.so.1", "gtk_scrollable_set_vscroll_policy", [
             {
-                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: policy,
             },
-        ], { 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 "columns-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 });
+            }
+            case "cursor-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 });
+            }
+            case "expand-collapse-cursor-row": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), args[1], args[2], 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: "boolean",
+                                },
+                                {
+                                    type: "boolean",
+                                },
+                                {
+                                    type: "boolean",
+                                },
+                            ],
+                            returnType: {
+                                type: "boolean",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "move-cursor": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), args[1], args[2], args[3], args[4]);
+                };
+                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: "int",
+                                    size: 32,
+                                    unsigned: false,
+                                },
+                                {
+                                    type: "int",
+                                    size: 32,
+                                    unsigned: false,
+                                },
+                                {
+                                    type: "boolean",
+                                },
+                                {
+                                    type: "boolean",
+                                },
+                            ],
+                            returnType: {
+                                type: "boolean",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "row-activated": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1], TreePath), getNativeObject(args[2]));
+                };
+                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: "gobject",
+                                    ownership: "none",
+                                },
+                            ],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "row-collapsed": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1], TreeIter), getNativeObject(args[2], 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: "GtkTreeIter",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gtk_tree_iter_get_type",
+                                },
+                                {
+                                    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-expanded": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1], TreeIter), getNativeObject(args[2], 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: "GtkTreeIter",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gtk_tree_iter_get_type",
+                                },
+                                {
+                                    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 "select-all": {
+                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: "boolean",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "select-cursor-parent": {
+                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: "boolean",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "select-cursor-row": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), args[1]);
+                };
+                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: "boolean",
+                                },
+                            ],
+                            returnType: {
+                                type: "boolean",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "start-interactive-search": {
+                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: "boolean",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "test-collapse-row": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1], TreeIter), getNativeObject(args[2], 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: "GtkTreeIter",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gtk_tree_iter_get_type",
+                                },
+                                {
+                                    type: "boxed",
+                                    ownership: "none",
+                                    innerType: "GtkTreePath",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gtk_tree_path_get_type",
+                                },
+                            ],
+                            returnType: {
+                                type: "boolean",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "test-expand-row": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1], TreeIter), getNativeObject(args[2], 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: "GtkTreeIter",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gtk_tree_iter_get_type",
+                                },
+                                {
+                                    type: "boxed",
+                                    ownership: "none",
+                                    innerType: "GtkTreePath",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gtk_tree_path_get_type",
+                                },
+                            ],
+                            returnType: {
+                                type: "boolean",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "toggle-cursor-row": {
+                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: "boolean",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "unselect-all": {
+                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: "boolean",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            default:
+                return super.connect(signal, handler, after);
+        }
     }
 }
 registerNativeClass(TreeView);