@gtkx/ffi 0.10.5 → 0.11.0

package/dist/generated/gtk/cell-area.js

@@ -1,8 +1,11 @@
 import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
-import { registerNativeClass, getNativeClass } from "../../registry.js";
+import { registerNativeClass } from "../../registry.js";
+import { TreeIter } from "./tree-iter.js";
 import { CellEditable } from "./cell-editable.js";
+import { TreeModel } from "./tree-model.js";
 import * as GObject from "../gobject/index.js";
+import * as Gdk from "../gdk/index.js";
 /**
  * An abstract class for laying out `GtkCellRenderer`s
  *
@@ -318,56 +321,6 @@ import * as GObject from "../gobject/index.js";
  * the value of a cell property, use {@link Gtk.CellArea.cell_get_property}
  * {@link Gtk.CellArea.cell_get} or {@link Gtk.CellArea.cell_get_valist}.
  */
-const SIGNAL_META = {
-    "add-editable": {
-        params: [
-            { type: "gobject", borrowed: true },
-            { type: "gobject", borrowed: true },
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GdkRectangle",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gdk_rectangle_get_type",
-            },
-            { type: "string", borrowed: true },
-        ],
-        returnType: { type: "undefined" },
-    },
-    "apply-attributes": {
-        params: [
-            { type: "gobject", borrowed: true },
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GtkTreeIter",
-                lib: "libgtk-4.so.1",
-                getTypeFn: "gtk_tree_iter_get_type",
-            },
-            { type: "boolean" },
-            { type: "boolean" },
-        ],
-        returnType: { type: "undefined" },
-    },
-    "focus-changed": {
-        params: [
-            { type: "gobject", borrowed: true },
-            { type: "string", borrowed: true },
-        ],
-        returnType: { type: "undefined" },
-    },
-    "remove-editable": {
-        params: [
-            { type: "gobject", borrowed: true },
-            { type: "gobject", borrowed: true },
-        ],
-        returnType: { type: "undefined" },
-    },
-    notify: {
-        params: [{ type: "gparam", borrowed: true }],
-        returnType: { type: "undefined" },
-    },
-};
 export class CellArea extends GObject.InitiallyUnowned {
     static glibTypeName = "GtkCellArea";
     static objectType = "gobject";
@@ -378,106 +331,136 @@ export class CellArea extends GObject.InitiallyUnowned {
      * Activates `area`, usually by activating the currently focused
      * cell, however some subclasses which embed widgets in the area
      * can also activate a widget if it currently has the focus.
-     * @param context - the `GtkCellArea`Context in context with the current row data
-     * @param widget - the `GtkWidget` that `area` is rendering on
-     * @param cellArea - the size and location of `area` relative to `widget`’s allocation
-     * @param flags - the `GtkCellRenderer`State flags for `area` for this row of data.
-     * @param editOnly - if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE
      */
     activate(context, widget, cellArea, flags, editOnly) {
         return call("libgtk-4.so.1", "gtk_cell_area_activate", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: context?.id ?? context,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: context.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: widget?.id ?? widget,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: widget.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRectangle",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rectangle_get_type",
                 },
-                value: cellArea?.id ?? cellArea,
+                value: cellArea.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: flags,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: editOnly,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * This is used by `GtkCellArea` subclasses when handling events
      * to activate cells, the base `GtkCellArea` class activates cells
      * for keyboard events for free in its own GtkCellArea->activate()
      * implementation.
-     * @param widget - the `GtkWidget` that `area` is rendering onto
-     * @param renderer - the `GtkCellRenderer` in `area` to activate
-     * @param event - the `GdkEvent` for which cell activation should occur
-     * @param cellArea - the `GdkRectangle` in `widget` relative coordinates
-     * @param flags - the `GtkCellRenderer`State for `renderer`
      */
     activateCell(widget, renderer, event, cellArea, flags) {
         return call("libgtk-4.so.1", "gtk_cell_area_activate_cell", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: widget?.id ?? widget,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: widget.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: event?.id ?? event,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: event.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRectangle",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rectangle_get_type",
                 },
-                value: cellArea?.id ?? cellArea,
+                value: cellArea.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: flags,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Adds `renderer` to `area` with the default child cell properties.
-     * @param renderer - the `GtkCellRenderer` to add to `area`
-     */
+    /** Adds `renderer` to `area` with the default child cell properties. */
     add(renderer) {
         call("libgtk-4.so.1", "gtk_cell_area_add", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Adds `sibling` to `renderer`’s focusable area, focus will be drawn
@@ -486,198 +469,259 @@ export class CellArea extends GObject.InitiallyUnowned {
      *
      * Events handled by focus siblings can also activate the given
      * focusable `renderer`.
-     * @param renderer - the `GtkCellRenderer` expected to have focus
-     * @param sibling - the `GtkCellRenderer` to add to `renderer`’s focus area
      */
     addFocusSibling(renderer, sibling) {
         call("libgtk-4.so.1", "gtk_cell_area_add_focus_sibling", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: sibling?.id ?? sibling,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: sibling.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Applies any connected attributes to the renderers in
      * `area` by pulling the values from `tree_model`.
-     * @param treeModel - the `GtkTreeModel` to pull values from
-     * @param iter - the `GtkTreeIter` in `tree_model` to apply values for
-     * @param isExpander - whether `iter` has children
-     * @param isExpanded - whether `iter` is expanded in the view and
      */
     applyAttributes(treeModel, iter, isExpander, isExpanded) {
         call("libgtk-4.so.1", "gtk_cell_area_apply_attributes", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: treeModel?.id ?? treeModel,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: treeModel.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTreeIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_tree_iter_get_type",
                 },
-                value: iter?.id ?? iter,
+                value: iter.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: isExpander,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: isExpanded,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Connects an `attribute` to apply values from `column` for the
      * `GtkTreeModel` in use.
-     * @param renderer - the `GtkCellRenderer` to connect an attribute for
-     * @param attribute - the attribute name
-     * @param column - the `GtkTreeModel` column to fetch attribute values from
      */
     attributeConnect(renderer, attribute, column) {
         call("libgtk-4.so.1", "gtk_cell_area_attribute_connect", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: attribute,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: column,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Disconnects `attribute` for the `renderer` in `area` so that
      * attribute will no longer be updated with values from the
      * model.
-     * @param renderer - the `GtkCellRenderer` to disconnect an attribute for
-     * @param attribute - the attribute name
      */
     attributeDisconnect(renderer, attribute) {
         call("libgtk-4.so.1", "gtk_cell_area_attribute_disconnect", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: attribute,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Returns the model column that an attribute has been mapped to,
      * or -1 if the attribute is not mapped.
-     * @param renderer - a `GtkCellRenderer`
-     * @param attribute - an attribute on the renderer
      */
     attributeGetColumn(renderer, attribute) {
         return call("libgtk-4.so.1", "gtk_cell_area_attribute_get_column", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: attribute,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
-    /**
-     * Gets the value of a cell property for `renderer` in `area`.
-     * @param renderer - a `GtkCellRenderer` inside `area`
-     * @param propertyName - the name of the property to get
-     * @param value - a location to return the value
-     */
+    /** Gets the value of a cell property for `renderer` in `area`. */
     cellGetProperty(renderer, propertyName, value) {
         call("libgtk-4.so.1", "gtk_cell_area_cell_get_property", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: propertyName,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GValue",
                     lib: "libgobject-2.0.so.0",
                     getTypeFn: "g_value_get_type",
                 },
-                value: value?.id ?? value,
+                value: value.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Sets a cell property for `renderer` in `area`.
-     * @param renderer - a `GtkCellRenderer` inside `area`
-     * @param propertyName - the name of the cell property to set
-     * @param value - the value to set the cell property to
-     */
+    /** Sets a cell property for `renderer` in `area`. */
     cellSetProperty(renderer, propertyName, value) {
         call("libgtk-4.so.1", "gtk_cell_area_cell_set_property", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: propertyName,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GValue",
                     lib: "libgobject-2.0.so.0",
                     getTypeFn: "g_value_get_type",
                 },
-                value: value?.id ?? value,
+                value: value.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * This is sometimes needed for cases where rows need to share
@@ -691,19 +735,27 @@ export class CellArea extends GObject.InitiallyUnowned {
      * request the heights of each row based on a context which
      * was already used to request all the row widths that are
      * to be displayed.
-     * @param context - the `GtkCellArea`Context to copy
      */
     copyContext(context) {
         const ptr = call("libgtk-4.so.1", "gtk_cell_area_copy_context", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: context?.id ?? context,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: context.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         return getNativeObject(ptr);
     }
     /**
@@ -717,53 +769,72 @@ export class CellArea extends GObject.InitiallyUnowned {
     createContext() {
         const ptr = call("libgtk-4.so.1", "gtk_cell_area_create_context", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         return getNativeObject(ptr);
     }
-    /**
-     * Delegates event handling to a `GtkCellArea`.
-     * @param context - the `GtkCellArea`Context for this row of data.
-     * @param widget - the `GtkWidget` that `area` is rendering to
-     * @param event - the `GdkEvent` to handle
-     * @param cellArea - the `widget` relative coordinates for `area`
-     * @param flags - the `GtkCellRenderer`State for `area` in this row.
-     */
+    /** Delegates event handling to a `GtkCellArea`. */
     event(context, widget, event, cellArea, flags) {
         return call("libgtk-4.so.1", "gtk_cell_area_event", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: context?.id ?? context,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: context.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: widget?.id ?? widget,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: widget.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: event?.id ?? event,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: event.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRectangle",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rectangle_get_type",
                 },
-                value: cellArea?.id ?? cellArea,
+                value: cellArea.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: flags,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * This should be called by the `area`’s owning layout widget
@@ -773,123 +844,154 @@ export class CellArea extends GObject.InitiallyUnowned {
      * Implementing `GtkCellArea` classes should implement this
      * method to receive and navigate focus in its own way particular
      * to how it lays out cells.
-     * @param direction - the `GtkDirectionType`
      */
     focus(direction) {
         return call("libgtk-4.so.1", "gtk_cell_area_focus", [
             {
-                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: direction,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Derives the allocation of `renderer` inside `area` if `area`
      * were to be rendered in `cell_area`.
-     * @param context - the `GtkCellArea`Context used to hold sizes for `area`.
-     * @param widget - the `GtkWidget` that `area` is rendering on
-     * @param renderer - the `GtkCellRenderer` to get the allocation for
-     * @param cellArea - the whole allocated area for `area` in `widget`
-     * @param allocation - where to store the allocation for `renderer`
      */
     getCellAllocation(context, widget, renderer, cellArea, allocation) {
         call("libgtk-4.so.1", "gtk_cell_area_get_cell_allocation", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: context?.id ?? context,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: context.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: widget?.id ?? widget,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: widget.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRectangle",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rectangle_get_type",
                 },
-                value: cellArea?.id ?? cellArea,
+                value: cellArea.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRectangle",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rectangle_get_type",
                 },
-                value: allocation?.id ?? allocation,
+                value: allocation.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Gets the `GtkCellRenderer` at `x` and `y` coordinates inside `area` and optionally
      * returns the full cell allocation for it inside `cell_area`.
-     * @param context - the `GtkCellArea`Context used to hold sizes for `area`.
-     * @param widget - the `GtkWidget` that `area` is rendering on
-     * @param cellArea - the whole allocated area for `area` in `widget`
-     * @param x - the x position
-     * @param y - the y position
-     * @param allocArea - where to store the inner allocated area of the
      */
     getCellAtPosition(context, widget, cellArea, x, y, allocArea) {
         const ptr = call("libgtk-4.so.1", "gtk_cell_area_get_cell_at_position", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: context?.id ?? context,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: context.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: widget?.id ?? widget,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: widget.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRectangle",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rectangle_get_type",
                 },
-                value: cellArea?.id ?? cellArea,
+                value: cellArea.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: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRectangle",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rectangle_get_type",
                 },
-                value: allocArea?.id ?? allocArea,
+                value: allocArea?.id,
                 optional: true,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         return getNativeObject(ptr);
     }
     /**
@@ -902,10 +1004,16 @@ export class CellArea extends GObject.InitiallyUnowned {
     getCurrentPathString() {
         return call("libgtk-4.so.1", "gtk_cell_area_get_current_path_string", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "string", borrowed: true });
+        ], {
+            type: "string",
+            ownership: "none",
+        });
     }
     /**
      * Gets the `GtkCellEditable` widget currently used
@@ -914,10 +1022,16 @@ export class CellArea extends GObject.InitiallyUnowned {
     getEditWidget() {
         const ptr = call("libgtk-4.so.1", "gtk_cell_area_get_edit_widget", [
             {
-                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, CellEditable);
@@ -929,24 +1043,34 @@ export class CellArea extends GObject.InitiallyUnowned {
     getEditedCell() {
         const ptr = call("libgtk-4.so.1", "gtk_cell_area_get_edited_cell", [
             {
-                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);
     }
-    /**
-     * Retrieves the currently focused cell for `area`
-     */
+    /** Retrieves the currently focused cell for `area` */
     getFocusCell() {
         const ptr = call("libgtk-4.so.1", "gtk_cell_area_get_focus_cell", [
             {
-                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);
@@ -959,44 +1083,58 @@ export class CellArea extends GObject.InitiallyUnowned {
      * after determining the renderer at the event location it can
      * then chose to activate the focus cell for which the event
      * cell may have been a sibling.
-     * @param renderer - the `GtkCellRenderer`
      */
     getFocusFromSibling(renderer) {
         const ptr = call("libgtk-4.so.1", "gtk_cell_area_get_focus_from_sibling", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
     }
-    /**
-     * Gets the focus sibling cell renderers for `renderer`.
-     * @param renderer - the `GtkCellRenderer` expected to have focus
-     */
+    /** Gets the focus sibling cell renderers for `renderer`. */
     getFocusSiblings(renderer) {
-        const ptrs = call("libgtk-4.so.1", "gtk_cell_area_get_focus_siblings", [
+        const arr = call("libgtk-4.so.1", "gtk_cell_area_get_focus_siblings", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer.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));
     }
     /**
      * Retrieves a cell area’s initial minimum and natural height.
@@ -1006,29 +1144,38 @@ export class CellArea extends GObject.InitiallyUnowned {
      * to check the `minimum_height` and `natural_height` of this call but rather to
      * consult gtk_cell_area_context_get_preferred_height() after a series of
      * requests.
-     * @param context - the `GtkCellArea`Context to perform this request with
-     * @param widget - the `GtkWidget` where `area` will be rendering
-     * @param minimumHeight - location to store the minimum height
-     * @param naturalHeight - location to store the natural height
      */
     getPreferredHeight(context, widget, minimumHeight, naturalHeight) {
         call("libgtk-4.so.1", "gtk_cell_area_get_preferred_height", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: context?.id ?? context,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: context.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: widget?.id ?? widget,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: widget.id,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: minimumHeight,
                 optional: true,
@@ -1036,12 +1183,18 @@ export class CellArea extends GObject.InitiallyUnowned {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: naturalHeight,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Retrieves a cell area’s minimum and natural height if it would be given
@@ -1058,34 +1211,46 @@ export class CellArea extends GObject.InitiallyUnowned {
      * requested with gtk_cell_area_get_preferred_width() again and then
      * the full width of the requested rows checked again with
      * gtk_cell_area_context_get_preferred_width().
-     * @param context - the `GtkCellArea`Context which has already been requested for widths.
-     * @param widget - the `GtkWidget` where `area` will be rendering
-     * @param width - the width for which to check the height of this area
-     * @param minimumHeight - location to store the minimum height
-     * @param naturalHeight - location to store the natural height
      */
     getPreferredHeightForWidth(context, widget, width, minimumHeight, naturalHeight) {
         call("libgtk-4.so.1", "gtk_cell_area_get_preferred_height_for_width", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: context?.id ?? context,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: context.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: widget?.id ?? widget,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: widget.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: width,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: minimumHeight,
                 optional: true,
@@ -1093,12 +1258,18 @@ export class CellArea extends GObject.InitiallyUnowned {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: naturalHeight,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Retrieves a cell area’s initial minimum and natural width.
@@ -1108,29 +1279,38 @@ export class CellArea extends GObject.InitiallyUnowned {
      * to check the `minimum_width` and `natural_width` of this call but rather to
      * consult gtk_cell_area_context_get_preferred_width() after a series of
      * requests.
-     * @param context - the `GtkCellArea`Context to perform this request with
-     * @param widget - the `GtkWidget` where `area` will be rendering
-     * @param minimumWidth - location to store the minimum width
-     * @param naturalWidth - location to store the natural width
      */
     getPreferredWidth(context, widget, minimumWidth, naturalWidth) {
         call("libgtk-4.so.1", "gtk_cell_area_get_preferred_width", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: context?.id ?? context,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: context.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: widget?.id ?? widget,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: widget.id,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: minimumWidth,
                 optional: true,
@@ -1138,12 +1318,18 @@ export class CellArea extends GObject.InitiallyUnowned {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: naturalWidth,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Retrieves a cell area’s minimum and natural width if it would be given
@@ -1160,34 +1346,46 @@ export class CellArea extends GObject.InitiallyUnowned {
      * requested with gtk_cell_area_get_preferred_height() again and then
      * the full height of the requested rows checked again with
      * gtk_cell_area_context_get_preferred_height().
-     * @param context - the `GtkCellArea`Context which has already been requested for widths.
-     * @param widget - the `GtkWidget` where `area` will be rendering
-     * @param height - the height for which to check the width of this area
-     * @param minimumWidth - location to store the minimum width
-     * @param naturalWidth - location to store the natural width
      */
     getPreferredWidthForHeight(context, widget, height, minimumWidth, naturalWidth) {
         call("libgtk-4.so.1", "gtk_cell_area_get_preferred_width_for_height", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: context?.id ?? context,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: context.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: widget?.id ?? widget,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: widget.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: height,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: minimumWidth,
                 optional: true,
@@ -1195,12 +1393,18 @@ export class CellArea extends GObject.InitiallyUnowned {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: naturalWidth,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Gets whether the area prefers a height-for-width layout
@@ -1209,66 +1413,83 @@ export class CellArea extends GObject.InitiallyUnowned {
     getRequestMode() {
         return call("libgtk-4.so.1", "gtk_cell_area_get_request_mode", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
-    /**
-     * Checks if `area` contains `renderer`.
-     * @param renderer - the `GtkCellRenderer` to check
-     */
+    /** Checks if `area` contains `renderer`. */
     hasRenderer(renderer) {
         return call("libgtk-4.so.1", "gtk_cell_area_has_renderer", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * This is a convenience function for `GtkCellArea` implementations
      * to get the inner area where a given `GtkCellRenderer` will be
      * rendered. It removes any padding previously added by gtk_cell_area_request_renderer().
-     * @param widget - the `GtkWidget` that `area` is rendering onto
-     * @param cellArea - the `widget` relative coordinates where one of `area`’s cells
-     * @param innerArea - the return location for the inner cell area
      */
     innerCellArea(widget, cellArea, innerArea) {
         call("libgtk-4.so.1", "gtk_cell_area_inner_cell_area", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: widget?.id ?? widget,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: widget.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRectangle",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rectangle_get_type",
                 },
-                value: cellArea?.id ?? cellArea,
+                value: cellArea.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRectangle",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rectangle_get_type",
                 },
-                value: innerArea?.id ?? innerArea,
+                value: innerArea.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Returns whether the area can do anything when activated,
@@ -1277,70 +1498,98 @@ export class CellArea extends GObject.InitiallyUnowned {
     isActivatable() {
         return call("libgtk-4.so.1", "gtk_cell_area_is_activatable", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Returns whether `sibling` is one of `renderer`’s focus siblings
      * (see gtk_cell_area_add_focus_sibling()).
-     * @param renderer - the `GtkCellRenderer` expected to have focus
-     * @param sibling - the `GtkCellRenderer` to check against `renderer`’s sibling list
      */
     isFocusSibling(renderer, sibling) {
         return call("libgtk-4.so.1", "gtk_cell_area_is_focus_sibling", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: sibling?.id ?? sibling,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: sibling.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Removes `renderer` from `area`.
-     * @param renderer - the `GtkCellRenderer` to remove from `area`
-     */
+    /** Removes `renderer` from `area`. */
     remove(renderer) {
         call("libgtk-4.so.1", "gtk_cell_area_remove", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Removes `sibling` from `renderer`’s focus sibling list
      * (see gtk_cell_area_add_focus_sibling()).
-     * @param renderer - the `GtkCellRenderer` expected to have focus
-     * @param sibling - the `GtkCellRenderer` to remove from `renderer`’s focus area
      */
     removeFocusSibling(renderer, sibling) {
         call("libgtk-4.so.1", "gtk_cell_area_remove_focus_sibling", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: sibling?.id ?? sibling,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: sibling.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * This is a convenience function for `GtkCellArea` implementations
@@ -1348,39 +1597,54 @@ export class CellArea extends GObject.InitiallyUnowned {
      * function to request size and then use gtk_cell_area_inner_cell_area()
      * at render and event time since this function will add padding
      * around the cell for focus painting.
-     * @param renderer - the `GtkCellRenderer` to request size for
-     * @param orientation - the `GtkOrientation` in which to request size
-     * @param widget - the `GtkWidget` that `area` is rendering onto
-     * @param forSize - the allocation contextual size to request for, or -1 if
-     * @param minimumSize - location to store the minimum size
-     * @param naturalSize - location to store the natural size
      */
     requestRenderer(renderer, orientation, widget, forSize, minimumSize, naturalSize) {
         call("libgtk-4.so.1", "gtk_cell_area_request_renderer", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: orientation,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: widget?.id ?? widget,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: widget.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: forSize,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: minimumSize,
                 optional: true,
@@ -1388,12 +1652,18 @@ export class CellArea extends GObject.InitiallyUnowned {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: naturalSize,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Explicitly sets the currently focused cell to `renderer`.
@@ -1402,79 +1672,99 @@ export class CellArea extends GObject.InitiallyUnowned {
      * `GtkCellAreaClass.focus()` or `GtkCellAreaClass.event()`,
      * however it can also be used to implement functions such
      * as gtk_tree_view_set_cursor_on_cell().
-     * @param renderer - the `GtkCellRenderer` to give focus to
      */
     setFocusCell(renderer) {
         call("libgtk-4.so.1", "gtk_cell_area_set_focus_cell", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: renderer?.id ?? renderer,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: renderer?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Snapshots `area`’s cells according to `area`’s layout onto at
      * the given coordinates.
-     * @param context - the `GtkCellArea`Context for this row of data.
-     * @param widget - the `GtkWidget` that `area` is rendering to
-     * @param snapshot - the `GtkSnapshot` to draw to
-     * @param backgroundArea - the `widget` relative coordinates for `area`’s background
-     * @param cellArea - the `widget` relative coordinates for `area`
-     * @param flags - the `GtkCellRenderer`State for `area` in this row.
-     * @param paintFocus - whether `area` should paint focus on focused cells for focused rows or not.
      */
     snapshot(context, widget, snapshot, backgroundArea, cellArea, flags, paintFocus) {
         call("libgtk-4.so.1", "gtk_cell_area_snapshot", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: context?.id ?? context,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: context.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: widget?.id ?? widget,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: widget.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: snapshot?.id ?? snapshot,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: snapshot.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRectangle",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rectangle_get_type",
                 },
-                value: backgroundArea?.id ?? backgroundArea,
+                value: backgroundArea.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRectangle",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rectangle_get_type",
                 },
-                value: cellArea?.id ?? cellArea,
+                value: cellArea.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: flags,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: paintFocus,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Explicitly stops the editing of the currently edited cell.
@@ -1485,19 +1775,25 @@ export class CellArea extends GObject.InitiallyUnowned {
      * edit widget.
      *
      * See gtk_cell_area_get_edited_cell() and gtk_cell_area_get_edit_widget().
-     * @param canceled - whether editing was canceled.
      */
     stopEditing(canceled) {
         call("libgtk-4.so.1", "gtk_cell_area_stop_editing", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: canceled,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Gets the ID of the `buildable` object.
@@ -1508,10 +1804,16 @@ export class CellArea extends GObject.InitiallyUnowned {
     getBuildableId() {
         return call("libgtk-4.so.1", "gtk_buildable_get_buildable_id", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "string", borrowed: true });
+        ], {
+            type: "string",
+            ownership: "none",
+        });
     }
     /**
      * Adds an attribute mapping to the list in `cell_layout`.
@@ -1521,29 +1823,41 @@ export class CellArea extends GObject.InitiallyUnowned {
      * example if column 2 of the model contains strings, you could have the
      * “text” attribute of a `GtkCellRendererText` get its values from column 2.
      * In this context "attribute" and "property" are used interchangeably.
-     * @param cell - a `GtkCellRenderer`
-     * @param attribute - a property on the renderer
-     * @param column - the column position on the model to get the attribute from
      */
     addAttribute(cell, attribute, column) {
         call("libgtk-4.so.1", "gtk_cell_layout_add_attribute", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cell?.id ?? cell,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cell.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: attribute,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: column,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Unsets all the mappings on all renderers on `cell_layout` and
@@ -1552,27 +1866,39 @@ export class CellArea extends GObject.InitiallyUnowned {
     clear() {
         call("libgtk-4.so.1", "gtk_cell_layout_clear", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Clears all existing attributes previously set with
      * gtk_cell_layout_set_attributes().
-     * @param cell - a `GtkCellRenderer` to clear the attribute mapping on
      */
     clearAttributes(cell) {
         call("libgtk-4.so.1", "gtk_cell_layout_clear_attributes", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cell?.id ?? cell,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cell.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Returns the underlying `GtkCellArea` which might be `cell_layout`
@@ -1582,30 +1908,40 @@ export class CellArea extends GObject.InitiallyUnowned {
     getArea() {
         const ptr = call("libgtk-4.so.1", "gtk_cell_layout_get_area", [
             {
-                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 the cell renderers which have been added to `cell_layout`.
-     */
+    /** Returns the cell renderers which have been added to `cell_layout`. */
     getCells() {
-        const ptrs = call("libgtk-4.so.1", "gtk_cell_layout_get_cells", [
+        const arr = call("libgtk-4.so.1", "gtk_cell_layout_get_cells", [
             {
-                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));
     }
     /**
      * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
@@ -1613,24 +1949,32 @@ export class CellArea extends GObject.InitiallyUnowned {
      * divided evenly between cells for which `expand` is %TRUE.
      *
      * Note that reusing the same cell renderer is not supported.
-     * @param cell - a `GtkCellRenderer`
-     * @param expand - %TRUE if `cell` is to be given extra space allocated to `cell_layout`
      */
     packEnd(cell, expand) {
         call("libgtk-4.so.1", "gtk_cell_layout_pack_end", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cell?.id ?? cell,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cell.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: expand,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
@@ -1638,84 +1982,216 @@ export class CellArea extends GObject.InitiallyUnowned {
      * is divided evenly between cells for which `expand` is %TRUE.
      *
      * Note that reusing the same cell renderer is not supported.
-     * @param cell - a `GtkCellRenderer`
-     * @param expand - %TRUE if `cell` is to be given extra space allocated to `cell_layout`
      */
     packStart(cell, expand) {
         call("libgtk-4.so.1", "gtk_cell_layout_pack_start", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cell?.id ?? cell,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cell.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: expand,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Re-inserts `cell` at `position`.
      *
      * Note that `cell` has already to be packed into `cell_layout`
      * for this to function properly.
-     * @param cell - a `GtkCellRenderer` to reorder
-     * @param position - new position to insert `cell` at
      */
     reorder(cell, position) {
         call("libgtk-4.so.1", "gtk_cell_layout_reorder", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cell?.id ?? cell,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cell.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: position,
             },
-        ], { 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 "add-editable": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1]), getNativeObject(args[2], CellEditable), getNativeObject(args[3], Gdk.Rectangle), 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: "gobject",
+                                    ownership: "none",
+                                },
+                                {
+                                    type: "gobject",
+                                    ownership: "none",
+                                },
+                                {
+                                    type: "boxed",
+                                    ownership: "none",
+                                    innerType: "GdkRectangle",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gdk_rectangle_get_type",
+                                },
+                                {
+                                    type: "string",
+                                    ownership: "none",
+                                },
+                            ],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "apply-attributes": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1], TreeModel), getNativeObject(args[2], TreeIter), 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: "gobject",
+                                    ownership: "none",
+                                },
+                                {
+                                    type: "boxed",
+                                    ownership: "none",
+                                    innerType: "GtkTreeIter",
+                                    lib: "libgtk-4.so.1",
+                                    getTypeFn: "gtk_tree_iter_get_type",
+                                },
+                                {
+                                    type: "boolean",
+                                },
+                                {
+                                    type: "boolean",
+                                },
+                            ],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "focus-changed": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1]), 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: "gobject",
+                                    ownership: "none",
+                                },
+                                {
+                                    type: "string",
+                                    ownership: "none",
+                                },
+                            ],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "remove-editable": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1]), getNativeObject(args[2], CellEditable));
+                };
+                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: "gobject",
+                                    ownership: "none",
+                                },
+                                {
+                                    type: "gobject",
+                                    ownership: "none",
+                                },
+                            ],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            default:
+                return super.connect(signal, handler, after);
+        }
     }
 }
 registerNativeClass(CellArea);