@gtkx/ffi 0.10.5 → 0.11.1

package/dist/generated/adw/leaflet.js

@@ -3,7 +3,6 @@ import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
 import { SpringParams } from "./spring-params.js";
-import * as GObject from "../gobject/index.js";
 import * as Gtk from "../gtk/index.js";
 /**
  * An adaptive container acting like a box or a stack.
@@ -32,18 +31,10 @@ import * as Gtk from "../gtk/index.js";
  * style classes `.folded` when it is folded, `.unfolded` when it's not, or none
  * if it hasn't computed its fold yet.
  */
-const SIGNAL_META = {
-    notify: {
-        params: [{ type: "gparam", borrowed: true }],
-        returnType: { type: "undefined" },
-    },
-};
 export class Leaflet extends Gtk.Widget {
     static glibTypeName = "AdwLeaflet";
     static objectType = "gobject";
-    /**
-     * Creates a new `AdwLeaflet`.
-     */
+    /** Creates a new `AdwLeaflet`. */
     constructor() {
         if (!isInstantiating) {
             setInstantiating(true);
@@ -52,7 +43,7 @@ export class Leaflet extends Gtk.Widget {
             setInstantiating(false);
             this.id = call("libadwaita-1.so.0", "adw_leaflet_new", [], {
                 type: "gobject",
-                borrowed: true,
+                ownership: "none",
             });
         }
         else {
@@ -60,21 +51,27 @@ export class Leaflet extends Gtk.Widget {
             super();
         }
     }
-    /**
-     * Adds a child to `self`.
-     * @param child - the widget to add
-     */
+    /** Adds a child to `self`. */
     append(child) {
         const ptr = call("libadwaita-1.so.0", "adw_leaflet_append", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: child?.id ?? child,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: child.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         return getNativeObject(ptr);
     }
     /**
@@ -86,55 +83,73 @@ export class Leaflet extends Gtk.Widget {
      * If there's no child to navigate to, `NULL` will be returned instead.
      *
      * See {@link LeafletPage.navigatable}.
-     * @param direction - the direction
      */
     getAdjacentChild(direction) {
         const ptr = call("libadwaita-1.so.0", "adw_leaflet_get_adjacent_child", [
             {
-                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: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
     }
-    /**
-     * Gets whether gestures and shortcuts for navigating backward are enabled.
-     */
+    /** Gets whether gestures and shortcuts for navigating backward are enabled. */
     getCanNavigateBack() {
         return call("libadwaita-1.so.0", "adw_leaflet_get_can_navigate_back", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Gets whether gestures and shortcuts for navigating forward are enabled.
-     */
+    /** Gets whether gestures and shortcuts for navigating forward are enabled. */
     getCanNavigateForward() {
         return call("libadwaita-1.so.0", "adw_leaflet_get_can_navigate_forward", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Gets whether `self` can unfold.
-     */
+    /** Gets whether `self` can unfold. */
     getCanUnfold() {
         return call("libadwaita-1.so.0", "adw_leaflet_get_can_unfold", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Finds the child of `self` with `name`.
@@ -142,62 +157,79 @@ export class Leaflet extends Gtk.Widget {
      * Returns `NULL` if there is no child with this name.
      *
      * See {@link LeafletPage.name}.
-     * @param name - the name of the child to find
      */
     getChildByName(name) {
         const ptr = call("libadwaita-1.so.0", "adw_leaflet_get_child_by_name", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: name,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
     }
-    /**
-     * Gets the child transition spring parameters for `self`.
-     */
+    /** Gets the child transition spring parameters for `self`. */
     getChildTransitionParams() {
         const ptr = call("libadwaita-1.so.0", "adw_leaflet_get_child_transition_params", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "AdwSpringParams",
             lib: "libadwaita-1.so.0",
             getTypeFn: "adw_spring_params_get_type",
         });
         return getNativeObject(ptr, SpringParams);
     }
-    /**
-     * Gets whether a child transition is currently running for `self`.
-     */
+    /** Gets whether a child transition is currently running for `self`. */
     getChildTransitionRunning() {
         return call("libadwaita-1.so.0", "adw_leaflet_get_child_transition_running", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Gets the fold threshold policy for `self`.
-     */
+    /** Gets the fold threshold policy for `self`. */
     getFoldThresholdPolicy() {
         return call("libadwaita-1.so.0", "adw_leaflet_get_fold_threshold_policy", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Gets whether `self` is folded.
@@ -209,48 +241,67 @@ export class Leaflet extends Gtk.Widget {
     getFolded() {
         return call("libadwaita-1.so.0", "adw_leaflet_get_folded", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Gets whether `self` is homogeneous.
-     */
+    /** Gets whether `self` is homogeneous. */
     getHomogeneous() {
         return call("libadwaita-1.so.0", "adw_leaflet_get_homogeneous", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Gets the mode transition animation duration for `self`.
-     */
+    /** Gets the mode transition animation duration for `self`. */
     getModeTransitionDuration() {
         return call("libadwaita-1.so.0", "adw_leaflet_get_mode_transition_duration", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: true });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
     }
-    /**
-     * Returns the {@link LeafletPage} object for `child`.
-     * @param child - a child of `self`
-     */
+    /** Returns the {@link LeafletPage} object for `child`. */
     getPage(child) {
         const ptr = call("libadwaita-1.so.0", "adw_leaflet_get_page", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: child?.id ?? child,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: child.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         return getNativeObject(ptr);
     }
     /**
@@ -263,71 +314,100 @@ export class Leaflet extends Gtk.Widget {
     getPages() {
         const ptr = call("libadwaita-1.so.0", "adw_leaflet_get_pages", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         return getNativeObject(ptr, Gtk.SelectionModel);
     }
-    /**
-     * Gets the type of animation used for transitions between modes and children.
-     */
+    /** Gets the type of animation used for transitions between modes and children. */
     getTransitionType() {
         return call("libadwaita-1.so.0", "adw_leaflet_get_transition_type", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
-    /**
-     * Gets the widget currently visible when the leaflet is folded.
-     */
+    /** Gets the widget currently visible when the leaflet is folded. */
     getVisibleChild() {
         const ptr = call("libadwaita-1.so.0", "adw_leaflet_get_visible_child", [
             {
-                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 name of the currently visible child widget.
-     */
+    /** Gets the name of the currently visible child widget. */
     getVisibleChildName() {
         return call("libadwaita-1.so.0", "adw_leaflet_get_visible_child_name", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "string", borrowed: true });
+        ], {
+            type: "string",
+            ownership: "none",
+        });
     }
     /**
      * Inserts `child` in the position after `sibling` in the list of children.
      *
      * If `sibling` is `NULL`, inserts `child` at the first position.
-     * @param child - the widget to insert
-     * @param sibling - the sibling after which to insert `child`
      */
     insertChildAfter(child, sibling) {
         const ptr = call("libadwaita-1.so.0", "adw_leaflet_insert_child_after", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: child?.id ?? child,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: child.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: sibling?.id ?? sibling,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: sibling?.id,
                 optional: true,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         return getNativeObject(ptr);
     }
     /**
@@ -338,76 +418,104 @@ export class Leaflet extends Gtk.Widget {
      *
      * This will be the same child as returned by
      * {@link Leaflet.get_adjacent_child} or navigated to via swipe gestures.
-     * @param direction - the direction
      */
     navigate(direction) {
         return call("libadwaita-1.so.0", "adw_leaflet_navigate", [
             {
-                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",
+        });
     }
-    /**
-     * Inserts `child` at the first position in `self`.
-     * @param child - the widget to prepend
-     */
+    /** Inserts `child` at the first position in `self`. */
     prepend(child) {
         const ptr = call("libadwaita-1.so.0", "adw_leaflet_prepend", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: child?.id ?? child,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: child.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         return getNativeObject(ptr);
     }
-    /**
-     * Removes a child widget from `self`.
-     * @param child - the child to remove
-     */
+    /** Removes a child widget from `self`. */
     remove(child) {
         call("libadwaita-1.so.0", "adw_leaflet_remove", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: child?.id ?? child,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: child.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Moves `child` to the position after `sibling` in the list of children.
      *
      * If `sibling` is `NULL`, moves `child` to the first position.
-     * @param child - the widget to move, must be a child of `self`
-     * @param sibling - the sibling to move `child` after
      */
     reorderChildAfter(child, sibling) {
         call("libadwaita-1.so.0", "adw_leaflet_reorder_child_after", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: child?.id ?? child,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: child.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: sibling?.id ?? sibling,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: sibling?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets whether gestures and shortcuts for navigating backward are enabled.
@@ -427,19 +535,25 @@ export class Leaflet extends Gtk.Widget {
      *
      * Only children that have {@link LeafletPage.navigatable} set to `TRUE` can
      * be navigated to.
-     * @param canNavigateBack - the new value
      */
     setCanNavigateBack(canNavigateBack) {
         call("libadwaita-1.so.0", "adw_leaflet_set_can_navigate_back", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: canNavigateBack,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets whether gestures and shortcuts for navigating forward are enabled.
@@ -459,35 +573,45 @@ export class Leaflet extends Gtk.Widget {
      *
      * Only children that have {@link LeafletPage.navigatable} set to `TRUE` can
      * be navigated to.
-     * @param canNavigateForward - the new value
      */
     setCanNavigateForward(canNavigateForward) {
         call("libadwaita-1.so.0", "adw_leaflet_set_can_navigate_forward", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: canNavigateForward,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Sets whether `self` can unfold.
-     * @param canUnfold - whether `self` can unfold
-     */
+    /** Sets whether `self` can unfold. */
     setCanUnfold(canUnfold) {
         call("libadwaita-1.so.0", "adw_leaflet_set_can_unfold", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: canUnfold,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the child transition spring parameters for `self`.
@@ -497,25 +621,29 @@ export class Leaflet extends Gtk.Widget {
      * ```c
      * adw_spring_params_new (1, 0.5, 500)
      * ```
-     * @param params - the new parameters
      */
     setChildTransitionParams(params) {
         call("libadwaita-1.so.0", "adw_leaflet_set_child_transition_params", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "AdwSpringParams",
                     lib: "libadwaita-1.so.0",
                     getTypeFn: "adw_spring_params_get_type",
                 },
-                value: params?.id ?? params,
+                value: params.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the fold threshold policy for `self`.
@@ -526,54 +654,74 @@ export class Leaflet extends Gtk.Widget {
      *
      * This can be useful if you have a long ellipsizing label and want to let it
      * ellipsize instead of immediately folding.
-     * @param policy - the policy to use
      */
     setFoldThresholdPolicy(policy) {
         call("libadwaita-1.so.0", "adw_leaflet_set_fold_threshold_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 `self` to be homogeneous or not.
      *
      * If set to `FALSE`, different children can have different size along the
      * opposite orientation.
-     * @param homogeneous - whether to make `self` homogeneous
      */
     setHomogeneous(homogeneous) {
         call("libadwaita-1.so.0", "adw_leaflet_set_homogeneous", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: homogeneous,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Sets the mode transition animation duration for `self`.
-     * @param duration - the new duration, in milliseconds
-     */
+    /** Sets the mode transition animation duration for `self`. */
     setModeTransitionDuration(duration) {
         call("libadwaita-1.so.0", "adw_leaflet_set_mode_transition_duration", [
             {
-                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: duration,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the type of animation used for transitions between modes and children.
@@ -581,19 +729,27 @@ export class Leaflet extends Gtk.Widget {
      * The transition type can be changed without problems at runtime, so it is
      * possible to change the animation based on the mode or child that is about to
      * become current.
-     * @param transition - the new transition type
      */
     setTransitionType(transition) {
         call("libadwaita-1.so.0", "adw_leaflet_set_transition_type", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: transition,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the widget currently visible when the leaflet is folded.
@@ -602,48 +758,66 @@ export class Leaflet extends Gtk.Widget {
      * {@link Leaflet.child-transition-params}. The transition can be cancelled
      * by the user, in which case visible child will change back to the previously
      * visible child.
-     * @param visibleChild - the new child
      */
     setVisibleChild(visibleChild) {
         call("libadwaita-1.so.0", "adw_leaflet_set_visible_child", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: visibleChild?.id ?? visibleChild,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: visibleChild.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Makes the child with the name `name` visible.
      *
      * See {@link Leaflet.visible-child}.
-     * @param name - the name of a child
      */
     setVisibleChildName(name) {
         call("libadwaita-1.so.0", "adw_leaflet_set_visible_child_name", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: name,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Gets the progress `self` will snap back to after the gesture is canceled.
-     */
+    /** Gets the progress `self` will snap back to after the gesture is canceled. */
     getCancelProgress() {
         return call("libadwaita-1.so.0", "adw_swipeable_get_cancel_progress", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "float", size: 64 });
+        ], {
+            type: "float",
+            size: 64,
+        });
     }
     /**
      * Gets the swipe distance of `self`.
@@ -653,43 +827,67 @@ export class Leaflet extends Gtk.Widget {
     getDistance() {
         return call("libadwaita-1.so.0", "adw_swipeable_get_distance", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "float", size: 64 });
+        ], {
+            type: "float",
+            size: 64,
+        });
     }
-    /**
-     * Gets the current progress of `self`.
-     */
+    /** Gets the current progress of `self`. */
     getProgress() {
         return call("libadwaita-1.so.0", "adw_swipeable_get_progress", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "float", size: 64 });
+        ], {
+            type: "float",
+            size: 64,
+        });
     }
     /**
      * Gets the snap points of `self`.
      *
      * Each snap point represents a progress value that is considered acceptable to
      * end the swipe on.
-     * @param nSnapPoints - location to return the number of the snap points
      */
     getSnapPoints(nSnapPoints) {
         return call("libadwaita-1.so.0", "adw_swipeable_get_snap_points", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: nSnapPoints,
             },
-        ], { type: "array", itemType: { type: "float", size: 64 } });
+        ], {
+            type: "array",
+            itemType: {
+                type: "float",
+                size: 64,
+            },
+            listType: "array",
+            ownership: "full",
+        });
     }
     /**
      * Gets the area `self` can start a swipe from for the given direction and
@@ -701,94 +899,81 @@ export class Leaflet extends Gtk.Widget {
      *
      * If not implemented, the default implementation returns the allocation of
      * `self`, allowing swipes from anywhere.
-     * @param navigationDirection - the direction of the swipe
-     * @param isDrag - whether the swipe is caused by a dragging gesture
-     * @param rect - a pointer to a rectangle to store the swipe area
      */
     getSwipeArea(navigationDirection, isDrag, rect) {
         call("libadwaita-1.so.0", "adw_swipeable_get_swipe_area", [
             {
-                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: navigationDirection,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: isDrag,
             },
             {
                 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",
+        });
     }
-    /**
-     * Retrieves the orientation of the `orientable`.
-     */
+    /** Retrieves the orientation of the `orientable`. */
     getOrientation() {
         return call("libadwaita-1.so.0", "gtk_orientable_get_orientation", [
             {
-                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 orientation of the `orientable`.
-     * @param orientation - the orientable’s new orientation
-     */
+    /** Sets the orientation of the `orientable`. */
     setOrientation(orientation) {
         call("libadwaita-1.so.0", "gtk_orientable_set_orientation", [
             {
-                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: orientation,
             },
-        ], { 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);
-                }
-                return callbackArgs[i];
-            });
-            const result = handler(self, ...wrapped);
-            return result;
-        };
-        return call("libadwaita-1.so.0", "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 });
+        ], {
+            type: "undefined",
+        });
     }
 }
 registerNativeClass(Leaflet);