@gtkx/ffi 0.10.5 → 0.11.0

package/dist/generated/gtk/snapshot.js

@@ -2,7 +2,6 @@ import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
-import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import * as cairo from "../cairo/index.js";
 /**
@@ -19,28 +18,17 @@ import * as cairo from "../cairo/index.js";
  * the {@link Gtk.Widget.snapshot} vfunc. If you need to create your own
  * `GtkSnapshot`, use {@link Gtk.Snapshot.new}.
  */
-const SIGNAL_META = {
-    notify: {
-        params: [{ type: "gparam", borrowed: true }],
-        returnType: { type: "undefined" },
-    },
-};
 export class Snapshot extends Gdk.Snapshot {
     static glibTypeName = "GtkSnapshot";
     static objectType = "gobject";
-    /**
-     * Creates a new `GtkSnapshot`.
-     */
+    /** Creates a new `GtkSnapshot`. */
     constructor() {
         if (!isInstantiating) {
             setInstantiating(true);
             // @ts-ignore
             super();
             setInstantiating(false);
-            this.id = call("libgtk-4.so.1", "gtk_snapshot_new", [], {
-                type: "gobject",
-                borrowed: false,
-            });
+            this.id = call("libgtk-4.so.1", "gtk_snapshot_new", [], { type: "gobject", ownership: "full" });
         }
         else {
             // @ts-ignore
@@ -51,22 +39,34 @@ export class Snapshot extends Gdk.Snapshot {
      * Appends a stroked border rectangle inside the given `outline`.
      *
      * The four sides of the border can have different widths and colors.
-     * @param outline - the outline of the border
-     * @param borderWidth - the stroke width of the border on
-     * @param borderColor - the color used on the top, right,
      */
     appendBorder(outline, borderWidth, borderColor) {
         call("libgtk-4.so.1", "gtk_snapshot_append_border", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
-                value: outline,
+                type: {
+                    type: "struct",
+                    ownership: "none",
+                    innerType: "RoundedRect",
+                },
+                value: outline.id,
             },
             {
-                type: { type: "array", itemType: { type: "float", size: 32 } },
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "float",
+                        size: 32,
+                    },
+                    listType: "array",
+                    ownership: "none",
+                },
                 value: borderWidth,
             },
             {
@@ -74,39 +74,46 @@ export class Snapshot extends Gdk.Snapshot {
                     type: "array",
                     itemType: {
                         type: "boxed",
+                        ownership: "none",
                         innerType: "GdkRGBA",
                         lib: "libgtk-4.so.1",
                         getTypeFn: "gdk_rgba_get_type",
                     },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: borderColor,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Creates a new {@link Gsk.CairoNode} and appends it to the current
      * render node of `snapshot`, without changing the current node.
-     * @param bounds - the bounds for the new node
      */
     appendCairo(bounds) {
         const ptr = call("libgtk-4.so.1", "gtk_snapshot_append_cairo", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: bounds?.id ?? bounds,
+                value: bounds.id,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "CairoContext",
             lib: "libcairo-gobject.so.2",
             getTypeFn: "cairo_gobject_context_get_type",
@@ -120,87 +127,101 @@ export class Snapshot extends Gdk.Snapshot {
      *
      * You should try to avoid calling this function if
      * `color` is transparent.
-     * @param color - the color to draw
-     * @param bounds - the bounds for the new node
      */
     appendColor(color, bounds) {
         call("libgtk-4.so.1", "gtk_snapshot_append_color", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRGBA",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rgba_get_type",
                 },
-                value: color?.id ?? color,
+                value: color.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: bounds?.id ?? bounds,
+                value: bounds.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Appends a conic gradient node with the given stops to `snapshot`.
-     * @param bounds - the rectangle to render the gradient into
-     * @param center - the center point of the conic gradient
-     * @param rotation - the clockwise rotation in degrees of the starting angle.
-     * @param stops - the color stops defining the gradient
-     * @param nStops - the number of elements in `stops`
-     */
+    /** Appends a conic gradient node with the given stops to `snapshot`. */
     appendConicGradient(bounds, center, rotation, stops, nStops) {
         call("libgtk-4.so.1", "gtk_snapshot_append_conic_gradient", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: bounds?.id ?? bounds,
+                value: bounds.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point_get_type",
                 },
-                value: center?.id ?? center,
+                value: center.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: rotation,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 64, unsigned: true },
+                    itemType: {
+                        type: "struct",
+                        ownership: "none",
+                        innerType: "ColorStop",
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: stops,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: nStops,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * A convenience method to fill a path with a color.
@@ -208,88 +229,107 @@ export class Snapshot extends Gdk.Snapshot {
      * See {@link Gtk.Snapshot.push_fill} if you need
      * to fill a path with more complex content than
      * a color.
-     * @param path - The path describing the area to fill
-     * @param fillRule - The fill rule to use
-     * @param color - the color to fill the path with
      */
     appendFill(path, fillRule, color) {
         call("libgtk-4.so.1", "gtk_snapshot_append_fill", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GskPath",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gsk_path_get_type",
                 },
-                value: path?.id ?? path,
+                value: path.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: fillRule,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRGBA",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rgba_get_type",
                 },
-                value: color?.id ?? color,
+                value: color.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Appends an inset shadow into the box given by `outline`.
-     * @param outline - outline of the region surrounded by shadow
-     * @param color - color of the shadow
-     * @param dx - horizontal offset of shadow
-     * @param dy - vertical offset of shadow
-     * @param spread - how far the shadow spreads towards the inside
-     * @param blurRadius - how much blur to apply to the shadow
-     */
+    /** Appends an inset shadow into the box given by `outline`. */
     appendInsetShadow(outline, color, dx, dy, spread, blurRadius) {
         call("libgtk-4.so.1", "gtk_snapshot_append_inset_shadow", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
-                value: outline,
+                type: {
+                    type: "struct",
+                    ownership: "none",
+                    innerType: "RoundedRect",
+                },
+                value: outline.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRGBA",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rgba_get_type",
                 },
-                value: color?.id ?? color,
+                value: color.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: dx,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: dy,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: spread,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: blurRadius,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Creates render nodes for rendering `layout` in the given foregound `color`
@@ -299,87 +339,101 @@ export class Snapshot extends Gdk.Snapshot {
      *
      * Note that if the layout does not produce any visible output, then nodes
      * may not be added to the `snapshot`.
-     * @param layout - the `PangoLayout` to render
-     * @param color - the foreground color to render the layout in
      */
     appendLayout(layout, color) {
         call("libgtk-4.so.1", "gtk_snapshot_append_layout", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: layout?.id ?? layout,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: layout.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRGBA",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rgba_get_type",
                 },
-                value: color?.id ?? color,
+                value: color.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Appends a linear gradient node with the given stops to `snapshot`.
-     * @param bounds - the rectangle to render the linear gradient into
-     * @param startPoint - the point at which the linear gradient will begin
-     * @param endPoint - the point at which the linear gradient will finish
-     * @param stops - the color stops defining the gradient
-     * @param nStops - the number of elements in `stops`
-     */
+    /** Appends a linear gradient node with the given stops to `snapshot`. */
     appendLinearGradient(bounds, startPoint, endPoint, stops, nStops) {
         call("libgtk-4.so.1", "gtk_snapshot_append_linear_gradient", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: bounds?.id ?? bounds,
+                value: bounds.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point_get_type",
                 },
-                value: startPoint?.id ?? startPoint,
+                value: startPoint.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point_get_type",
                 },
-                value: endPoint?.id ?? endPoint,
+                value: endPoint.id,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 64, unsigned: true },
+                    itemType: {
+                        type: "struct",
+                        ownership: "none",
+                        innerType: "ColorStop",
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: stops,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: nStops,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Appends `node` to the current render node of `snapshot`,
@@ -387,255 +441,317 @@ export class Snapshot extends Gdk.Snapshot {
      *
      * If `snapshot` does not have a current node yet, `node`
      * will become the initial node.
-     * @param node - a `GskRenderNode`
      */
     appendNode(node) {
         call("libgtk-4.so.1", "gtk_snapshot_append_node", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: node?.id ?? node,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: node.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Appends an outset shadow node around the box given by `outline`.
-     * @param outline - outline of the region surrounded by shadow
-     * @param color - color of the shadow
-     * @param dx - horizontal offset of shadow
-     * @param dy - vertical offset of shadow
-     * @param spread - how far the shadow spreads towards the outside
-     * @param blurRadius - how much blur to apply to the shadow
-     */
+    /** Appends an outset shadow node around the box given by `outline`. */
     appendOutsetShadow(outline, color, dx, dy, spread, blurRadius) {
         call("libgtk-4.so.1", "gtk_snapshot_append_outset_shadow", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
-                value: outline,
+                type: {
+                    type: "struct",
+                    ownership: "none",
+                    innerType: "RoundedRect",
+                },
+                value: outline.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRGBA",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rgba_get_type",
                 },
-                value: color?.id ?? color,
+                value: color.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: dx,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: dy,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: spread,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: blurRadius,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Appends a radial gradient node with the given stops to `snapshot`.
-     * @param bounds - the rectangle to render the readial gradient into
-     * @param center - the center point for the radial gradient
-     * @param hradius - the horizontal radius
-     * @param vradius - the vertical radius
-     * @param start - the start position (on the horizontal axis)
-     * @param end - the end position (on the horizontal axis)
-     * @param stops - the color stops defining the gradient
-     * @param nStops - the number of elements in `stops`
-     */
+    /** Appends a radial gradient node with the given stops to `snapshot`. */
     appendRadialGradient(bounds, center, hradius, vradius, start, end, stops, nStops) {
         call("libgtk-4.so.1", "gtk_snapshot_append_radial_gradient", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: bounds?.id ?? bounds,
+                value: bounds.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point_get_type",
                 },
-                value: center?.id ?? center,
+                value: center.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: hradius,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: vradius,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: start,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: end,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 64, unsigned: true },
+                    itemType: {
+                        type: "struct",
+                        ownership: "none",
+                        innerType: "ColorStop",
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: stops,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: nStops,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Appends a repeating linear gradient node with the given stops to `snapshot`.
-     * @param bounds - the rectangle to render the linear gradient into
-     * @param startPoint - the point at which the linear gradient will begin
-     * @param endPoint - the point at which the linear gradient will finish
-     * @param stops - the color stops defining the gradient
-     * @param nStops - the number of elements in `stops`
-     */
+    /** Appends a repeating linear gradient node with the given stops to `snapshot`. */
     appendRepeatingLinearGradient(bounds, startPoint, endPoint, stops, nStops) {
         call("libgtk-4.so.1", "gtk_snapshot_append_repeating_linear_gradient", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: bounds?.id ?? bounds,
+                value: bounds.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point_get_type",
                 },
-                value: startPoint?.id ?? startPoint,
+                value: startPoint.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point_get_type",
                 },
-                value: endPoint?.id ?? endPoint,
+                value: endPoint.id,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 64, unsigned: true },
+                    itemType: {
+                        type: "struct",
+                        ownership: "none",
+                        innerType: "ColorStop",
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: stops,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: nStops,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Appends a repeating radial gradient node with the given stops to `snapshot`.
-     * @param bounds - the rectangle to render the readial gradient into
-     * @param center - the center point for the radial gradient
-     * @param hradius - the horizontal radius
-     * @param vradius - the vertical radius
-     * @param start - the start position (on the horizontal axis)
-     * @param end - the end position (on the horizontal axis)
-     * @param stops - the color stops defining the gradient
-     * @param nStops - the number of elements in `stops`
-     */
+    /** Appends a repeating radial gradient node with the given stops to `snapshot`. */
     appendRepeatingRadialGradient(bounds, center, hradius, vradius, start, end, stops, nStops) {
         call("libgtk-4.so.1", "gtk_snapshot_append_repeating_radial_gradient", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: bounds?.id ?? bounds,
+                value: bounds.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point_get_type",
                 },
-                value: center?.id ?? center,
+                value: center.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: hradius,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: vradius,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: start,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: end,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 64, unsigned: true },
+                    itemType: {
+                        type: "struct",
+                        ownership: "none",
+                        innerType: "ColorStop",
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: stops,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: nStops,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Creates a new render node drawing the `texture`
@@ -645,35 +761,44 @@ export class Snapshot extends Gdk.Snapshot {
      * In contrast to {@link Gtk.Snapshot.append_texture},
      * this function provides control about how the filter
      * that is used when scaling.
-     * @param texture - the texture to render
-     * @param filter - the filter to use
-     * @param bounds - the bounds for the new node
      */
     appendScaledTexture(texture, filter, bounds) {
         call("libgtk-4.so.1", "gtk_snapshot_append_scaled_texture", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: texture?.id ?? texture,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: texture.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: filter,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: bounds?.id ?? bounds,
+                value: bounds.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * A convenience method to stroke a path with a color.
@@ -681,47 +806,49 @@ export class Snapshot extends Gdk.Snapshot {
      * See {@link Gtk.Snapshot.push_stroke} if you need
      * to stroke a path with more complex content than
      * a color.
-     * @param path - The path describing the area to fill
-     * @param stroke - The stroke attributes
-     * @param color - the color to fill the path with
      */
     appendStroke(path, stroke, color) {
         call("libgtk-4.so.1", "gtk_snapshot_append_stroke", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GskPath",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gsk_path_get_type",
                 },
-                value: path?.id ?? path,
+                value: path.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GskStroke",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gsk_stroke_get_type",
                 },
-                value: stroke?.id ?? stroke,
+                value: stroke.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GdkRGBA",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gdk_rgba_get_type",
                 },
-                value: color?.id ?? color,
+                value: color.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Creates a new render node drawing the `texture`
@@ -731,30 +858,36 @@ export class Snapshot extends Gdk.Snapshot {
      * If the texture needs to be scaled to fill `bounds`,
      * linear filtering is used. See {@link Gtk.Snapshot.append_scaled_texture}
      * if you need other filtering, such as nearest-neighbour.
-     * @param texture - the texture to render
-     * @param bounds - the bounds for the new node
      */
     appendTexture(texture, bounds) {
         call("libgtk-4.so.1", "gtk_snapshot_append_texture", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: texture?.id ?? texture,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: texture.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: bounds?.id ?? bounds,
+                value: bounds.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Removes the top element from the stack of render nodes and
@@ -767,28 +900,40 @@ export class Snapshot extends Gdk.Snapshot {
     glShaderPopTexture() {
         call("libgtk-4.so.1", "gtk_snapshot_gl_shader_pop_texture", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Applies a perspective projection transform.
      *
      * See {@link Gsk.Transform.perspective} for a discussion on the details.
-     * @param depth - distance of the z=0 plane
      */
     perspective(depth) {
         call("libgtk-4.so.1", "gtk_snapshot_perspective", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: depth,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Removes the top element from the stack of render nodes,
@@ -797,10 +942,15 @@ export class Snapshot extends Gdk.Snapshot {
     pop() {
         call("libgtk-4.so.1", "gtk_snapshot_pop", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Blends together two images with the given blend mode.
@@ -812,61 +962,80 @@ export class Snapshot extends Gdk.Snapshot {
      *
      * Calling this function requires two subsequent calls
      * to {@link Gtk.Snapshot.pop}.
-     * @param blendMode - blend mode to use
      */
     pushBlend(blendMode) {
         call("libgtk-4.so.1", "gtk_snapshot_push_blend", [
             {
-                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: blendMode,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Blurs an image.
      *
      * The image is recorded until the next call to {@link Gtk.Snapshot.pop}.
-     * @param radius - the blur radius to use. Must be positive
      */
     pushBlur(radius) {
         call("libgtk-4.so.1", "gtk_snapshot_push_blur", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: radius,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Clips an image to a rectangle.
      *
      * The image is recorded until the next call to {@link Gtk.Snapshot.pop}.
-     * @param bounds - the rectangle to clip to
      */
     pushClip(bounds) {
         call("libgtk-4.so.1", "gtk_snapshot_push_clip", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: bounds?.id ?? bounds,
+                value: bounds.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Modifies the colors of an image by applying an affine transformation
@@ -874,42 +1043,45 @@ export class Snapshot extends Gdk.Snapshot {
      *
      * In particular, the colors will be transformed by applying
      *
-     * pixel = transpose(color_matrix) * pixel + color_offset
+     *     pixel = transpose(color_matrix) * pixel + color_offset
      *
      * for every pixel. The transformation operates on unpremultiplied
      * colors, with color components ordered R, G, B, A.
      *
      * The image is recorded until the next call to {@link Gtk.Snapshot.pop}.
-     * @param colorMatrix - the color matrix to use
-     * @param colorOffset - the color offset to use
      */
     pushColorMatrix(colorMatrix, colorOffset) {
         call("libgtk-4.so.1", "gtk_snapshot_push_color_matrix", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_matrix_get_type",
                 },
-                value: colorMatrix?.id ?? colorMatrix,
+                value: colorMatrix.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec4",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec4_get_type",
                 },
-                value: colorOffset?.id ?? colorOffset,
+                value: colorOffset.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Modifies the colors of an image by applying a transfer
@@ -918,58 +1090,59 @@ export class Snapshot extends Gdk.Snapshot {
      * The transfer functions operate on unpremultiplied colors.
      *
      * The image is recorded until the next call to {@link Gtk.Snapshot.pop}.
-     * @param red - the transfer for the red component
-     * @param green - the transfer for the green component
-     * @param blue - the transfer for the blue component
-     * @param alpha - the transfer for the alpha component
      */
     pushComponentTransfer(red, green, blue, alpha) {
         call("libgtk-4.so.1", "gtk_snapshot_push_component_transfer", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GskComponentTransfer",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gsk_component_transfer_get_type",
                 },
-                value: red?.id ?? red,
+                value: red.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GskComponentTransfer",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gsk_component_transfer_get_type",
                 },
-                value: green?.id ?? green,
+                value: green.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GskComponentTransfer",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gsk_component_transfer_get_type",
                 },
-                value: blue?.id ?? blue,
+                value: blue.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GskComponentTransfer",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gsk_component_transfer_get_type",
                 },
-                value: alpha?.id ?? alpha,
+                value: alpha.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Snapshots a cross-fade operation between two images with the
@@ -981,19 +1154,26 @@ export class Snapshot extends Gdk.Snapshot {
      *
      * Calling this function requires two subsequent calls
      * to {@link Gtk.Snapshot.pop}.
-     * @param progress - progress between 0.0 and 1.0
      */
     pushCrossFade(progress) {
         call("libgtk-4.so.1", "gtk_snapshot_push_cross_fade", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: progress,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Fills the area given by `path` and `fill_rule` with an image and discards everything
@@ -1004,30 +1184,37 @@ export class Snapshot extends Gdk.Snapshot {
      * If you want to fill the path with a color, {@link Gtk.Snapshot.append_fill}
      * than rendering new ones, use {@link Gtk.Snapshot.append_fill}
      * may be more convenient.
-     * @param path - The path describing the area to fill
-     * @param fillRule - The fill rule to use
      */
     pushFill(path, fillRule) {
         call("libgtk-4.so.1", "gtk_snapshot_push_fill", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GskPath",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gsk_path_get_type",
                 },
-                value: path?.id ?? path,
+                value: path.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: fillRule,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Push a {@link Gsk.GLShaderNode}.
@@ -1064,40 +1251,46 @@ export class Snapshot extends Gdk.Snapshot {
      * re-rendered.
      *
      * For details on how to write shaders, see {@link Gsk.GLShader}.
-     * @param shader - The code to run
-     * @param bounds - the rectangle to render into
-     * @param takeArgs - Data block with arguments for the shader.
      */
     pushGlShader(shader, bounds, takeArgs) {
         call("libgtk-4.so.1", "gtk_snapshot_push_gl_shader", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: shader?.id ?? shader,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: shader.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: bounds?.id ?? bounds,
+                value: bounds.id,
             },
             {
                 type: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GBytes",
                     lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                     getTypeFn: "g_bytes_get_type",
                 },
-                value: takeArgs?.id ?? takeArgs,
+                value: takeArgs.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Until the first call to {@link Gtk.Snapshot.pop}, the
@@ -1107,117 +1300,156 @@ export class Snapshot extends Gdk.Snapshot {
      * the second call to {@link Gtk.Snapshot.pop}.
      *
      * Calling this function requires 2 subsequent calls to gtk_snapshot_pop().
-     * @param maskMode - mask mode to use
      */
     pushMask(maskMode) {
         call("libgtk-4.so.1", "gtk_snapshot_push_mask", [
             {
-                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: maskMode,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Modifies the opacity of an image.
      *
      * The image is recorded until the next call to {@link Gtk.Snapshot.pop}.
-     * @param opacity - the opacity to use
      */
     pushOpacity(opacity) {
         call("libgtk-4.so.1", "gtk_snapshot_push_opacity", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: opacity,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Creates a node that repeats the child node.
      *
      * The child is recorded until the next call to {@link Gtk.Snapshot.pop}.
-     * @param bounds - the bounds within which to repeat
-     * @param childBounds - the bounds of the child or %NULL
      */
     pushRepeat(bounds, childBounds) {
         call("libgtk-4.so.1", "gtk_snapshot_push_repeat", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: bounds?.id ?? bounds,
+                value: bounds.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneRect",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_rect_get_type",
                 },
-                value: childBounds?.id ?? childBounds,
+                value: childBounds?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Clips an image to a rounded rectangle.
      *
      * The image is recorded until the next call to {@link Gtk.Snapshot.pop}.
-     * @param bounds - the rounded rectangle to clip to
      */
     pushRoundedClip(bounds) {
         call("libgtk-4.so.1", "gtk_snapshot_push_rounded_clip", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
-                value: bounds,
+                type: {
+                    type: "struct",
+                    ownership: "none",
+                    innerType: "RoundedRect",
+                },
+                value: bounds.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Applies a shadow to an image.
      *
      * The image is recorded until the next call to {@link Gtk.Snapshot.pop}.
-     * @param shadow - the first shadow specification
-     * @param nShadows - number of shadow specifications
      */
     pushShadow(shadow, nShadows) {
         call("libgtk-4.so.1", "gtk_snapshot_push_shadow", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 64, unsigned: true },
+                    itemType: {
+                        type: "struct",
+                        ownership: "none",
+                        innerType: "Shadow",
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: shadow,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: nShadows,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Strokes the given `path` with the attributes given by `stroke` and
@@ -1231,224 +1463,302 @@ export class Snapshot extends Gdk.Snapshot {
      *
      * If you want to stroke the path with a color, {@link Gtk.Snapshot.append_stroke}
      * may be more convenient.
-     * @param path - The path to stroke
-     * @param stroke - The stroke attributes
      */
     pushStroke(path, stroke) {
         call("libgtk-4.so.1", "gtk_snapshot_push_stroke", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GskPath",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gsk_path_get_type",
                 },
-                value: path?.id ?? path,
+                value: path.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GskStroke",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gsk_stroke_get_type",
                 },
-                value: stroke?.id ?? stroke,
+                value: stroke.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Creates a render node for the CSS background according to `context`,
      * and appends it to the current node of `snapshot`, without changing
      * the current node.
-     * @param context - the style context that defines the background
-     * @param x - X origin of the rectangle
-     * @param y - Y origin of the rectangle
-     * @param width - rectangle width
-     * @param height - rectangle height
      */
     renderBackground(context, x, y, width, height) {
         call("libgtk-4.so.1", "gtk_snapshot_render_background", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: context?.id ?? context,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: context.id,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: x,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: y,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: width,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: height,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Creates a render node for the focus outline according to `context`,
      * and appends it to the current node of `snapshot`, without changing
      * the current node.
-     * @param context - the style context that defines the focus ring
-     * @param x - X origin of the rectangle
-     * @param y - Y origin of the rectangle
-     * @param width - rectangle width
-     * @param height - rectangle height
      */
     renderFocus(context, x, y, width, height) {
         call("libgtk-4.so.1", "gtk_snapshot_render_focus", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: context?.id ?? context,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: context.id,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: x,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: y,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: width,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: height,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Creates a render node for the CSS border according to `context`,
      * and appends it to the current node of `snapshot`, without changing
      * the current node.
-     * @param context - the style context that defines the frame
-     * @param x - X origin of the rectangle
-     * @param y - Y origin of the rectangle
-     * @param width - rectangle width
-     * @param height - rectangle height
      */
     renderFrame(context, x, y, width, height) {
         call("libgtk-4.so.1", "gtk_snapshot_render_frame", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: context?.id ?? context,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: context.id,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: x,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: y,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: width,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: height,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Draws a text caret using `snapshot` at the specified index of `layout`.
-     * @param context - a `GtkStyleContext`
-     * @param x - X origin
-     * @param y - Y origin
-     * @param layout - the `PangoLayout` of the text
-     * @param index - the index in the `PangoLayout`
-     * @param direction - the `PangoDirection` of the text
-     */
+    /** Draws a text caret using `snapshot` at the specified index of `layout`. */
     renderInsertionCursor(context, x, y, layout, index, direction) {
         call("libgtk-4.so.1", "gtk_snapshot_render_insertion_cursor", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: context?.id ?? context,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: context.id,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: x,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: y,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: layout?.id ?? layout,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: layout.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: index,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: direction,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Creates a render node for rendering `layout` according to the style
      * information in `context`, and appends it to the current node of `snapshot`,
      * without changing the current node.
-     * @param context - the style context that defines the text
-     * @param x - X origin of the rectangle
-     * @param y - Y origin of the rectangle
-     * @param layout - the `PangoLayout` to render
      */
     renderLayout(context, x, y, layout) {
         call("libgtk-4.so.1", "gtk_snapshot_render_layout", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: context?.id ?? context,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: context.id,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: x,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: y,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: layout?.id ?? layout,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: layout.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Restores `snapshot` to the state saved by a preceding call to
@@ -1458,10 +1768,15 @@ export class Snapshot extends Gdk.Snapshot {
     restore() {
         call("libgtk-4.so.1", "gtk_snapshot_restore", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Rotates @`snapshot`'s coordinate system by `angle` degrees in 2D space -
@@ -1469,48 +1784,61 @@ export class Snapshot extends Gdk.Snapshot {
      * the origin point of (0, 0) in the `snapshot`'s current coordinate system.
      *
      * To rotate around axes other than the Z axis, use {@link Gsk.Transform.rotate_3d}.
-     * @param angle - the rotation angle, in degrees (clockwise)
      */
     rotate(angle) {
         call("libgtk-4.so.1", "gtk_snapshot_rotate", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: angle,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Rotates `snapshot`'s coordinate system by `angle` degrees around `axis`.
      *
      * For a rotation in 2D space, use {@link Gsk.Transform.rotate}.
-     * @param angle - the rotation angle, in degrees (clockwise)
-     * @param axis - The rotation axis
      */
     rotate_3d(angle, axis) {
         call("libgtk-4.so.1", "gtk_snapshot_rotate_3d", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: angle,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneVec3",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_vec3_get_type",
                 },
-                value: axis?.id ?? axis,
+                value: axis.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Makes a copy of the current state of `snapshot` and saves it
@@ -1529,60 +1857,83 @@ export class Snapshot extends Gdk.Snapshot {
     save() {
         call("libgtk-4.so.1", "gtk_snapshot_save", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Scales `snapshot`'s coordinate system in 2-dimensional space by
      * the given factors.
      *
      * Use {@link Gtk.Snapshot.scale_3d} to scale in all 3 dimensions.
-     * @param factorX - scaling factor on the X axis
-     * @param factorY - scaling factor on the Y axis
      */
     scale(factorX, factorY) {
         call("libgtk-4.so.1", "gtk_snapshot_scale", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: factorX,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: factorY,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Scales `snapshot`'s coordinate system by the given factors.
-     * @param factorX - scaling factor on the X axis
-     * @param factorY - scaling factor on the Y axis
-     * @param factorZ - scaling factor on the Z axis
-     */
+    /** Scales `snapshot`'s coordinate system by the given factors. */
     scale_3d(factorX, factorY, factorZ) {
         call("libgtk-4.so.1", "gtk_snapshot_scale_3d", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: factorX,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: factorY,
             },
             {
-                type: { type: "float", size: 32 },
+                type: {
+                    type: "float",
+                    size: 32,
+                },
                 value: factorZ,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Returns the render node that was constructed
@@ -1599,10 +1950,16 @@ export class Snapshot extends Gdk.Snapshot {
     toNode() {
         const ptr = call("libgtk-4.so.1", "gtk_snapshot_to_node", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
@@ -1614,150 +1971,131 @@ export class Snapshot extends Gdk.Snapshot {
      * After calling this function, it is no longer possible to
      * add more nodes to `snapshot`. The only function that should
      * be called after this is {@link GObject.Object.unref}.
-     * @param size - The size of the resulting paintable
      */
     toPaintable(size) {
         const ptr = call("libgtk-4.so.1", "gtk_snapshot_to_paintable", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneSize",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_size_get_type",
                 },
-                value: size?.id ?? size,
+                value: size?.id,
                 optional: true,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr, Gdk.Paintable);
     }
-    /**
-     * Transforms `snapshot`'s coordinate system with the given `transform`.
-     * @param transform - the transform to apply
-     */
+    /** Transforms `snapshot`'s coordinate system with the given `transform`. */
     transform(transform) {
         call("libgtk-4.so.1", "gtk_snapshot_transform", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GskTransform",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gsk_transform_get_type",
                 },
-                value: transform?.id ?? transform,
+                value: transform?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Transforms `snapshot`'s coordinate system with the given `matrix`.
-     * @param matrix - the matrix to multiply the transform with
-     */
+    /** Transforms `snapshot`'s coordinate system with the given `matrix`. */
     transformMatrix(matrix) {
         call("libgtk-4.so.1", "gtk_snapshot_transform_matrix", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GrapheneMatrix",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_matrix_get_type",
                 },
-                value: matrix?.id ?? matrix,
+                value: matrix.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Translates `snapshot`'s coordinate system by `point` in 2-dimensional space.
-     * @param point - the point to translate the snapshot by
-     */
+    /** Translates `snapshot`'s coordinate system by `point` in 2-dimensional space. */
     translate(point) {
         call("libgtk-4.so.1", "gtk_snapshot_translate", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point_get_type",
                 },
-                value: point?.id ?? point,
+                value: point.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Translates `snapshot`'s coordinate system by `point`.
-     * @param point - the point to translate the snapshot by
-     */
+    /** Translates `snapshot`'s coordinate system by `point`. */
     translate_3d(point) {
         call("libgtk-4.so.1", "gtk_snapshot_translate_3d", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GraphenePoint3D",
                     lib: "libgraphene-1.0.so.0",
                     getTypeFn: "graphene_point3d_get_type",
                 },
-                value: point?.id ?? point,
+                value: point.id,
             },
-        ], { 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 });
+        ], {
+            type: "undefined",
+        });
     }
 }
 registerNativeClass(Snapshot);