@gtkx/ffi 0.10.5 → 0.11.0

package/dist/generated/gtk/spin-button.js

@@ -3,7 +3,6 @@ import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
 import { Editable } from "./editable.js";
-import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 /**
  * Allows to enter or change numeric values.
@@ -124,87 +123,10 @@ import { Widget } from "./widget.js";
  *
  * `GtkSpinButton` uses the {@link Gtk.AccessibleRole.spin_button} role.
  */
-const SIGNAL_META = {
-    activate: { params: [], returnType: { type: "undefined" } },
-    "change-value": {
-        params: [{ type: "int", size: 32, unsigned: false }],
-        returnType: { type: "undefined" },
-    },
-    input: {
-        params: [{ type: "ref", innerType: { type: "float", size: 64 } }],
-        returnType: { type: "int", size: 32, unsigned: false },
-    },
-    output: { params: [], returnType: { type: "boolean" } },
-    "value-changed": { params: [], returnType: { type: "undefined" } },
-    wrapped: { params: [], returnType: { type: "undefined" } },
-    "editing-done": { params: [], returnType: { type: "undefined" } },
-    "remove-widget": { params: [], returnType: { type: "undefined" } },
-    changed: { params: [], returnType: { type: "undefined" } },
-    "delete-text": {
-        params: [
-            { type: "int", size: 32, unsigned: false },
-            { type: "int", size: 32, unsigned: false },
-        ],
-        returnType: { type: "undefined" },
-    },
-    "insert-text": {
-        params: [
-            { type: "string", borrowed: true },
-            { type: "int", size: 32, unsigned: false },
-            { type: "ref", innerType: { type: "int", size: 32, unsigned: false } },
-        ],
-        returnType: { type: "undefined" },
-    },
-    destroy: { params: [], returnType: { type: "undefined" } },
-    "direction-changed": {
-        params: [{ type: "int", size: 32, unsigned: false }],
-        returnType: { type: "undefined" },
-    },
-    hide: { params: [], returnType: { type: "undefined" } },
-    "keynav-failed": {
-        params: [{ type: "int", size: 32, unsigned: false }],
-        returnType: { type: "boolean" },
-    },
-    map: { params: [], returnType: { type: "undefined" } },
-    "mnemonic-activate": {
-        params: [{ type: "boolean" }],
-        returnType: { type: "boolean" },
-    },
-    "move-focus": {
-        params: [{ type: "int", size: 32, unsigned: false }],
-        returnType: { type: "undefined" },
-    },
-    "query-tooltip": {
-        params: [
-            { type: "int", size: 32, unsigned: false },
-            { type: "int", size: 32, unsigned: false },
-            { type: "boolean" },
-            { type: "gobject", borrowed: true },
-        ],
-        returnType: { type: "boolean" },
-    },
-    realize: { params: [], returnType: { type: "undefined" } },
-    show: { params: [], returnType: { type: "undefined" } },
-    "state-flags-changed": {
-        params: [{ type: "int", size: 32, unsigned: true }],
-        returnType: { type: "undefined" },
-    },
-    unmap: { params: [], returnType: { type: "undefined" } },
-    unrealize: { params: [], returnType: { type: "undefined" } },
-    notify: {
-        params: [{ type: "gparam", borrowed: true }],
-        returnType: { type: "undefined" },
-    },
-};
 export class SpinButton extends Widget {
     static glibTypeName = "GtkSpinButton";
     static objectType = "gobject";
-    /**
-     * Creates a new `GtkSpinButton`.
-     * @param adjustment - the `GtkAdjustment` that this spin button should use
-     * @param climbRate - specifies by how much the rate of change in the value will
-     * @param digits - the number of decimal places to display
-     */
+    /** Creates a new `GtkSpinButton`. */
     constructor(climbRate, digits, adjustment) {
         if (!isInstantiating) {
             setInstantiating(true);
@@ -213,19 +135,31 @@ export class SpinButton extends Widget {
             setInstantiating(false);
             this.id = call("libgtk-4.so.1", "gtk_spin_button_new", [
                 {
-                    type: { type: "gobject", borrowed: true },
-                    value: adjustment?.id ?? adjustment,
+                    type: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    value: adjustment?.id,
                     optional: true,
                 },
                 {
-                    type: { type: "float", size: 64 },
+                    type: {
+                        type: "float",
+                        size: 64,
+                    },
                     value: climbRate,
+                    optional: false,
                 },
                 {
-                    type: { type: "int", size: 32, unsigned: true },
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
                     value: digits,
+                    optional: false,
                 },
-            ], { type: "gobject", borrowed: true });
+            ], { type: "gobject", ownership: "none" });
         }
         else {
             // @ts-ignore
@@ -246,25 +180,37 @@ export class SpinButton extends Widget {
      * best if `step` is a power of ten. If the resulting precision
      * is not suitable for your needs, use
      * {@link Gtk.SpinButton.set_digits} to correct it.
-     * @param min - Minimum allowable value
-     * @param max - Maximum allowable value
-     * @param step - Increment added or subtracted by spinning the widget
      */
-    static buttonNewWithRange(min, max, step) {
+    static newWithRange(min, max, step) {
         const ptr = call("libgtk-4.so.1", "gtk_spin_button_new_with_range", [
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: min,
+                optional: false,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: max,
+                optional: false,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: step,
+                optional: false,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         return getNativeObject(ptr);
     }
     /**
@@ -272,148 +218,212 @@ export class SpinButton extends Widget {
      *
      * The adjustment, climb rate, and number of decimal places
      * are updated accordingly.
-     * @param adjustment - a `GtkAdjustment` to replace the spin button’s
-     * @param climbRate - the new climb rate
-     * @param digits - the number of decimal places to display in the spin button
      */
     configure(climbRate, digits, adjustment) {
         call("libgtk-4.so.1", "gtk_spin_button_configure", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: adjustment?.id ?? adjustment,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: adjustment?.id,
                 optional: true,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: climbRate,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: digits,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Retrieves the value set by {@link Gtk.SpinButton.set_activates_default}.
-     */
+    /** Retrieves the value set by {@link Gtk.SpinButton.set_activates_default}. */
     getActivatesDefault() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_activates_default", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Get the adjustment associated with a `GtkSpinButton`.
-     */
+    /** Get the adjustment associated with a `GtkSpinButton`. */
     getAdjustment() {
         const ptr = call("libgtk-4.so.1", "gtk_spin_button_get_adjustment", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         return getNativeObject(ptr);
     }
-    /**
-     * Returns the acceleration rate for repeated changes.
-     */
+    /** Returns the acceleration rate for repeated changes. */
     getClimbRate() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_climb_rate", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "float", size: 64 });
+        ], {
+            type: "float",
+            size: 64,
+        });
     }
-    /**
-     * Fetches the precision of `spin_button`.
-     */
+    /** Fetches the precision of `spin_button`. */
     getDigits() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_digits", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: true });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
     }
     /**
      * Gets the current step and page the increments
      * used by `spin_button`.
      *
      * See {@link Gtk.SpinButton.set_increments}.
-     * @param step - location to store step increment
-     * @param page - location to store page increment
      */
     getIncrements(step, page) {
         call("libgtk-4.so.1", "gtk_spin_button_get_increments", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "ref", innerType: { type: "float", size: 64 } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 64,
+                    },
+                },
                 value: step,
                 optional: true,
             },
             {
-                type: { type: "ref", innerType: { type: "float", size: 64 } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 64,
+                    },
+                },
                 value: page,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Returns whether non-numeric text can be typed into the spin button.
-     */
+    /** Returns whether non-numeric text can be typed into the spin button. */
     getNumeric() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_numeric", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Gets the range allowed for `spin_button`.
      *
      * See {@link Gtk.SpinButton.set_range}.
-     * @param min - location to store minimum allowed value
-     * @param max - location to store maximum allowed value
      */
     getRange(min, max) {
         call("libgtk-4.so.1", "gtk_spin_button_get_range", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "ref", innerType: { type: "float", size: 64 } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 64,
+                    },
+                },
                 value: min,
                 optional: true,
             },
             {
-                type: { type: "ref", innerType: { type: "float", size: 64 } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 64,
+                    },
+                },
                 value: max,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Returns whether the values are corrected to the nearest step.
-     */
+    /** Returns whether the values are corrected to the nearest step. */
     getSnapToTicks() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_snap_to_ticks", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Gets the update behavior of a spin button.
@@ -423,32 +433,48 @@ export class SpinButton extends Widget {
     getUpdatePolicy() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_update_policy", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
-    /**
-     * Get the value in the `spin_button`.
-     */
+    /** Get the value in the `spin_button`. */
     getValue() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_value", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "float", size: 64 });
+        ], {
+            type: "float",
+            size: 64,
+        });
     }
-    /**
-     * Get the value `spin_button` represented as an integer.
-     */
+    /** Get the value `spin_button` represented as an integer. */
     getValueAsInt() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_value_as_int", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Returns whether the spin button’s value wraps around to the
@@ -458,271 +484,370 @@ export class SpinButton extends Widget {
     getWrap() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_wrap", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Sets whether activating the spin button will activate the default
      * widget for the window containing the spin button.
      *
      * See {@link Gtk.SpinButton.:activate} for what counts as activation.
-     * @param activatesDefault - %TRUE to activate window’s default widget on activation
      */
     setActivatesDefault(activatesDefault) {
         call("libgtk-4.so.1", "gtk_spin_button_set_activates_default", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: activatesDefault,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Replaces the `GtkAdjustment` associated with `spin_button`.
-     * @param adjustment - a `GtkAdjustment` to replace the existing adjustment
-     */
+    /** Replaces the `GtkAdjustment` associated with `spin_button`. */
     setAdjustment(adjustment) {
         call("libgtk-4.so.1", "gtk_spin_button_set_adjustment", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: adjustment?.id ?? adjustment,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: adjustment.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the acceleration rate for repeated changes when you
      * hold down a button or key.
-     * @param climbRate - the rate of acceleration, must be >= 0
      */
     setClimbRate(climbRate) {
         call("libgtk-4.so.1", "gtk_spin_button_set_climb_rate", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: climbRate,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Set the precision to be displayed by `spin_button`.
      *
      * Up to 20 digit precision is allowed.
-     * @param digits - the number of digits after the decimal point to be
      */
     setDigits(digits) {
         call("libgtk-4.so.1", "gtk_spin_button_set_digits", [
             {
-                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: digits,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the step and page increments for spin_button.
      *
      * This affects how quickly the value changes when
      * the spin button’s arrows are activated.
-     * @param step - increment applied for a button 1 press.
-     * @param page - increment applied for a button 2 press.
      */
     setIncrements(step, page) {
         call("libgtk-4.so.1", "gtk_spin_button_set_increments", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: step,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: page,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the flag that determines if non-numeric text can be typed
      * into the spin button.
-     * @param numeric - flag indicating if only numeric entry is allowed
      */
     setNumeric(numeric) {
         call("libgtk-4.so.1", "gtk_spin_button_set_numeric", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: numeric,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the minimum and maximum allowable values for `spin_button`.
      *
      * If the current value is outside this range, it will be adjusted
      * to fit within the range, otherwise it will remain unchanged.
-     * @param min - minimum allowable value
-     * @param max - maximum allowable value
      */
     setRange(min, max) {
         call("libgtk-4.so.1", "gtk_spin_button_set_range", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: min,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: max,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the policy as to whether values are corrected to the
      * nearest step increment when a spin button is activated after
      * providing an invalid value.
-     * @param snapToTicks - a flag indicating if invalid values should be corrected
      */
     setSnapToTicks(snapToTicks) {
         call("libgtk-4.so.1", "gtk_spin_button_set_snap_to_ticks", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: snapToTicks,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the update behavior of a spin button.
      *
      * This determines whether the spin button is always
      * updated or only when a valid value is set.
-     * @param policy - a `GtkSpinButtonUpdatePolicy` value
      */
     setUpdatePolicy(policy) {
         call("libgtk-4.so.1", "gtk_spin_button_set_update_policy", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: policy,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Sets the value of `spin_button`.
-     * @param value - the new value
-     */
+    /** Sets the value of `spin_button`. */
     setValue(value) {
         call("libgtk-4.so.1", "gtk_spin_button_set_value", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: value,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the flag that determines if a spin button value wraps
      * around to the opposite limit when the upper or lower limit
      * of the range is exceeded.
-     * @param wrap - a flag indicating if wrapping behavior is performed
      */
     setWrap(wrap) {
         call("libgtk-4.so.1", "gtk_spin_button_set_wrap", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: wrap,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Increment or decrement a spin button’s value in a specified
      * direction by a specified amount.
-     * @param direction - a `GtkSpinType` indicating the direction to spin
-     * @param increment - step increment to apply in the specified direction
      */
     spin(direction, increment) {
         call("libgtk-4.so.1", "gtk_spin_button_spin", [
             {
-                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: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: increment,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Manually force an update of the spin button.
-     */
+    /** Manually force an update of the spin button. */
     update() {
         call("libgtk-4.so.1", "gtk_spin_button_update", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Emits the `GtkCellEditable::editing-done` signal.
-     */
+    /** Emits the `GtkCellEditable::editing-done` signal. */
     editingDone() {
         call("libgtk-4.so.1", "gtk_cell_editable_editing_done", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Emits the `GtkCellEditable::remove-widget` signal.
-     */
+    /** Emits the `GtkCellEditable::remove-widget` signal. */
     removeWidget() {
         call("libgtk-4.so.1", "gtk_cell_editable_remove_widget", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Begins editing on a `cell_editable`.
@@ -735,20 +860,27 @@ export class SpinButton extends Widget {
      *
      * Note that the `cell_editable` is created on-demand for the current edit; its
      * lifetime is temporary and does not persist across other edits and/or cells.
-     * @param event - The `GdkEvent` that began the editing process, or
      */
     startEditing(event) {
         call("libgtk-4.so.1", "gtk_cell_editable_start_editing", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: event?.id ?? event,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: event?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Retrieves the accessible platform state from the editable delegate.
@@ -783,19 +915,27 @@ export class SpinButton extends Widget {
      * So, if you can't ensure the direct child condition, you should give the
      * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
      * change your tree to allow this function to work.
-     * @param state - what kind of accessible state to retrieve
      */
     delegateGetAccessiblePlatformState(state) {
         return call("libgtk-4.so.1", "gtk_editable_delegate_get_accessible_platform_state", [
             {
-                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: state,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Deletes the currently selected text of the editable.
@@ -805,10 +945,15 @@ export class SpinButton extends Widget {
     deleteSelection() {
         call("libgtk-4.so.1", "gtk_editable_delete_selection", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Deletes a sequence of characters.
@@ -819,24 +964,35 @@ export class SpinButton extends Widget {
      * the end of the text.
      *
      * Note that the positions are specified in characters, not bytes.
-     * @param startPos - start position
-     * @param endPos - end position
      */
     deleteText(startPos, endPos) {
         call("libgtk-4.so.1", "gtk_editable_delete_text", [
             {
-                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: startPos,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: endPos,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Undoes the setup done by {@link Gtk.Editable.init_delegate}.
@@ -847,21 +1003,30 @@ export class SpinButton extends Widget {
     finishDelegate() {
         call("libgtk-4.so.1", "gtk_editable_finish_delegate", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Gets the alignment of the editable.
-     */
+    /** Gets the alignment of the editable. */
     getAlignment() {
         return call("libgtk-4.so.1", "gtk_editable_get_alignment", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "float", size: 32 });
+        ], {
+            type: "float",
+            size: 32,
+        });
     }
     /**
      * Retrieves a sequence of characters.
@@ -872,24 +1037,36 @@ export class SpinButton extends Widget {
      * the end of the text.
      *
      * Note that positions are specified in characters, not bytes.
-     * @param startPos - start of text
-     * @param endPos - end of text
      */
     getChars(startPos, endPos) {
         return call("libgtk-4.so.1", "gtk_editable_get_chars", [
             {
-                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: startPos,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: endPos,
             },
-        ], { type: "string" });
+        ], {
+            type: "string",
+            ownership: "full",
+        });
     }
     /**
      * Gets the `GtkEditable` that `editable` is delegating its
@@ -900,46 +1077,63 @@ export class SpinButton extends Widget {
     getDelegate() {
         const ptr = call("libgtk-4.so.1", "gtk_editable_get_delegate", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr, Editable);
     }
-    /**
-     * Retrieves whether `editable` is editable.
-     */
+    /** Retrieves whether `editable` is editable. */
     getEditable() {
         return call("libgtk-4.so.1", "gtk_editable_get_editable", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Gets if undo/redo actions are enabled for `editable`
-     */
+    /** Gets if undo/redo actions are enabled for `editable` */
     getEnableUndo() {
         return call("libgtk-4.so.1", "gtk_editable_get_enable_undo", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Retrieves the desired maximum width of `editable`, in characters.
-     */
+    /** Retrieves the desired maximum width of `editable`, in characters. */
     getMaxWidthChars() {
         return call("libgtk-4.so.1", "gtk_editable_get_max_width_chars", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Retrieves the current position of the cursor relative
@@ -950,10 +1144,17 @@ export class SpinButton extends Widget {
     getPosition() {
         return call("libgtk-4.so.1", "gtk_editable_get_position", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Retrieves the selection bound of the editable.
@@ -963,19 +1164,24 @@ export class SpinButton extends Widget {
      * and %FALSE will be returned.
      *
      * Note that positions are specified in characters, not bytes.
-     * @param startPos - location to store the starting position
-     * @param endPos - location to store the end position
      */
     getSelectionBounds(startPos, endPos) {
         return call("libgtk-4.so.1", "gtk_editable_get_selection_bounds", [
             {
-                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: startPos,
                 optional: true,
@@ -983,12 +1189,18 @@ export class SpinButton extends Widget {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: endPos,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Retrieves the contents of `editable`.
@@ -998,10 +1210,16 @@ export class SpinButton extends Widget {
     getText() {
         return call("libgtk-4.so.1", "gtk_editable_get_text", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "string", borrowed: true });
+        ], {
+            type: "string",
+            ownership: "none",
+        });
     }
     /**
      * Gets the number of characters of space reserved
@@ -1010,10 +1228,17 @@ export class SpinButton extends Widget {
     getWidthChars() {
         return call("libgtk-4.so.1", "gtk_editable_get_width_chars", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Sets up a delegate for `GtkEditable`.
@@ -1027,10 +1252,15 @@ export class SpinButton extends Widget {
     initDelegate() {
         call("libgtk-4.so.1", "gtk_editable_init_delegate", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Inserts `length` bytes of `text` into the contents of the
@@ -1039,32 +1269,45 @@ export class SpinButton extends Widget {
      * Note that the position is in characters, not in bytes.
      * The function updates `position` to point after the newly
      * inserted text.
-     * @param text - the text to insert
-     * @param length - the length of the text in bytes, or -1
-     * @param position - location of the position text will be inserted at
      */
     insertText(text, length, position) {
         call("libgtk-4.so.1", "gtk_editable_insert_text", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: text,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: length,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: position,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Selects a region of text.
@@ -1075,59 +1318,81 @@ export class SpinButton extends Widget {
      * `start_pos` to  the end of the text.
      *
      * Note that positions are specified in characters, not bytes.
-     * @param startPos - start of region
-     * @param endPos - end of region
      */
     selectRegion(startPos, endPos) {
         call("libgtk-4.so.1", "gtk_editable_select_region", [
             {
-                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: startPos,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: endPos,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the alignment for the contents of the editable.
      *
      * This controls the horizontal positioning of the contents when
      * the displayed text is shorter than the width of the editable.
-     * @param xalign - The horizontal alignment, from 0 (left) to 1 (right).
      */
     setAlignment(xalign) {
         call("libgtk-4.so.1", "gtk_editable_set_alignment", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: xalign,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Determines if the user can edit the text in the editable widget.
-     * @param isEditable - %TRUE if the user is allowed to edit the text
-     */
+    /** Determines if the user can edit the text in the editable widget. */
     setEditable(isEditable) {
         call("libgtk-4.so.1", "gtk_editable_set_editable", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: isEditable,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * If enabled, changes to `editable` will be saved for undo/redo
@@ -1136,35 +1401,47 @@ export class SpinButton extends Widget {
      * This results in an additional copy of text changes and are not
      * stored in secure memory. As such, undo is forcefully disabled
      * when {@link Gtk.Text.visibility} is set to %FALSE.
-     * @param enableUndo - if undo/redo should be enabled
      */
     setEnableUndo(enableUndo) {
         call("libgtk-4.so.1", "gtk_editable_set_enable_undo", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: enableUndo,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Sets the desired maximum width in characters of `editable`.
-     * @param nChars - the new desired maximum width, in characters
-     */
+    /** Sets the desired maximum width in characters of `editable`. */
     setMaxWidthChars(nChars) {
         call("libgtk-4.so.1", "gtk_editable_set_max_width_chars", [
             {
-                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: nChars,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the cursor position in the editable to the given value.
@@ -1174,37 +1451,52 @@ export class SpinButton extends Widget {
      * or equal to the number of characters in the editable. A value of -1
      * indicates that the position should be set after the last character
      * of the editable. Note that `position` is in characters, not in bytes.
-     * @param position - the position of the cursor
      */
     setPosition(position) {
         call("libgtk-4.so.1", "gtk_editable_set_position", [
             {
-                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: position,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the text in the editable to the given value.
      *
      * This is replacing the current contents.
-     * @param text - the text to set
      */
     setText(text) {
         call("libgtk-4.so.1", "gtk_editable_set_text", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: text,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Changes the size request of the editable to be about the
@@ -1213,78 +1505,351 @@ export class SpinButton extends Widget {
      * Note that it changes the size request, the size can still
      * be affected by how you pack the widget into containers.
      * If `n_chars` is -1, the size reverts to the default size.
-     * @param nChars - width in chars
      */
     setWidthChars(nChars) {
         call("libgtk-4.so.1", "gtk_editable_set_width_chars", [
             {
-                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: nChars,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Retrieves the orientation of the `orientable`.
-     */
+    /** Retrieves the orientation of the `orientable`. */
     getOrientation() {
         return call("libgtk-4.so.1", "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("libgtk-4.so.1", "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" });
+        ], {
+            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("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 "activate": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]));
+                };
+                return call("libgtk-4.so.1", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [{ type: "gobject", ownership: "none" }],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "change-value": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), args[1]);
+                };
+                return call("libgtk-4.so.1", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [
+                                { type: "gobject", ownership: "none" },
+                                {
+                                    type: "int",
+                                    size: 32,
+                                    unsigned: false,
+                                },
+                            ],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "input": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), args[1]);
+                };
+                return call("libgtk-4.so.1", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [
+                                { type: "gobject", ownership: "none" },
+                                {
+                                    type: "ref",
+                                    innerType: {
+                                        type: "float",
+                                        size: 64,
+                                    },
+                                },
+                            ],
+                            returnType: {
+                                type: "int",
+                                size: 32,
+                                unsigned: false,
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "output": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]));
+                };
+                return call("libgtk-4.so.1", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [{ type: "gobject", ownership: "none" }],
+                            returnType: {
+                                type: "boolean",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "value-changed": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]));
+                };
+                return call("libgtk-4.so.1", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [{ type: "gobject", ownership: "none" }],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "wrapped": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]));
+                };
+                return call("libgtk-4.so.1", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [{ type: "gobject", ownership: "none" }],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "editing-done": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]));
+                };
+                return call("libgtk-4.so.1", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [{ type: "gobject", ownership: "none" }],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "remove-widget": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]));
+                };
+                return call("libgtk-4.so.1", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [{ type: "gobject", ownership: "none" }],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "changed": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]));
+                };
+                return call("libgtk-4.so.1", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [{ type: "gobject", ownership: "none" }],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "delete-text": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), 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: "int",
+                                    size: 32,
+                                    unsigned: false,
+                                },
+                                {
+                                    type: "int",
+                                    size: 32,
+                                    unsigned: false,
+                                },
+                            ],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "insert-text": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), args[1], args[2], args[3]);
+                };
+                return call("libgtk-4.so.1", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [
+                                { type: "gobject", ownership: "none" },
+                                {
+                                    type: "string",
+                                    ownership: "none",
+                                },
+                                {
+                                    type: "int",
+                                    size: 32,
+                                    unsigned: false,
+                                },
+                                {
+                                    type: "ref",
+                                    innerType: {
+                                        type: "int",
+                                        size: 32,
+                                        unsigned: false,
+                                    },
+                                },
+                            ],
+                            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(SpinButton);