@gtkx/ffi 0.10.5 → 0.11.0

package/dist/generated/gtk/text-iter.js

@@ -18,15 +18,7 @@ export class TextIter extends NativeObject {
     static objectType = "boxed";
     constructor() {
         super();
-        this.id = this.createPtr({});
-    }
-    createPtr(_init) {
-        return alloc(80, "GtkTextIter", "libgtk-4.so.1");
-    }
-    static fromPtr(ptr) {
-        const instance = Object.create(TextIter.prototype);
-        instance.id = ptr;
-        return instance;
+        this.id = alloc(80, "GtkTextIter", "libgtk-4.so.1");
     }
     /**
      * Assigns the value of `other` to `iter`.
@@ -35,14 +27,13 @@ export class TextIter extends NativeObject {
      * iterators can be assigned with `GtkTextIter i = j;`.
      *
      * The function is used by language bindings.
-     * @param other - another `GtkTextIter`
      */
     assign(other) {
         call("libgtk-4.so.1", "gtk_text_iter_assign", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
@@ -51,14 +42,16 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_text_iter_get_type",
                 },
-                value: other?.id ?? other,
+                value: other.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Moves backward by one character offset.
@@ -72,13 +65,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `count` characters backward, if possible.
@@ -90,63 +85,73 @@ export class TextIter extends NativeObject {
      * onto a dereferenceable position; if the iterator didn’t move, or
      * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
      * the function does nothing and returns %FALSE.
-     * @param count - number of characters to move
      */
     backwardChars(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_chars", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: count,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Like {@link Gtk.TextIter.forward_cursor_position}, but moves backward.
-     */
+    /** Like {@link Gtk.TextIter.forward_cursor_position}, but moves backward. */
     backwardCursorPosition() {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_cursor_position", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves up to `count` cursor positions.
      *
      * See {@link Gtk.TextIter.forward_cursor_position} for details.
-     * @param count - number of positions to move
      */
     backwardCursorPositions(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_cursor_positions", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: count,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `iter` to the start of the previous line.
@@ -164,13 +169,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `count` lines backward, if possible.
@@ -183,89 +190,98 @@ export class TextIter extends NativeObject {
      * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
      * the function does nothing and returns %FALSE. If `count` is negative,
      * moves forward by 0 - `count` lines.
-     * @param count - number of lines to move backward
      */
     backwardLines(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_lines", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: count,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Same as {@link Gtk.TextIter.forward_search}, but moves backward.
      *
      * `match_end` will never be set to a `GtkTextIter` located after `iter`,
      * even if there is a possible `match_start` before or at `iter`.
-     * @param str - search string
-     * @param flags - bitmask of flags affecting the search
-     * @param matchStart - return location for start of match
-     * @param matchEnd - return location for end of match
-     * @param limit - location of last possible `match_start`, or %NULL for start of buffer
      */
     backwardSearch(str, flags, matchStart, matchEnd, limit) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_search", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: str,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: flags,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_text_iter_get_type",
                 },
-                value: matchStart?.id ?? matchStart,
+                value: matchStart?.id,
                 optional: true,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_text_iter_get_type",
                 },
-                value: matchEnd?.id ?? matchEnd,
+                value: matchEnd?.id,
                 optional: true,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_text_iter_get_type",
                 },
-                value: limit?.id ?? limit,
+                value: limit?.id,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves backward to the previous sentence start.
@@ -281,36 +297,43 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Calls {@link Gtk.TextIter.backward_sentence_start} up to `count` times.
      *
      * If `count` is negative, moves forward instead of backward.
-     * @param count - number of sentences to move
      */
     backwardSentenceStarts(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_sentence_starts", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: count,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves backward to the next toggle (on or off) of the
@@ -322,25 +345,29 @@ export class TextIter extends NativeObject {
      * located at `iter`, only toggles before `iter`. Sets `iter`
      * to the location of the toggle, or the start of the buffer
      * if no toggle is found.
-     * @param tag - a `GtkTextTag`
      */
     backwardToTagToggle(tag) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_to_tag_toggle", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: tag?.id ?? tag,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: tag?.id,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `iter` backward to the previous visible cursor position.
@@ -352,36 +379,43 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves up to `count` visible cursor positions.
      *
      * See {@link Gtk.TextIter.backward_cursor_position} for details.
-     * @param count - number of positions to move
      */
     backwardVisibleCursorPositions(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_visible_cursor_positions", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: count,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `iter` to the start of the previous visible line.
@@ -399,13 +433,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `count` visible lines backward, if possible.
@@ -418,24 +454,29 @@ export class TextIter extends NativeObject {
      * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
      * the function does nothing and returns %FALSE. If `count` is negative,
      * moves forward by 0 - `count` lines.
-     * @param count - number of lines to move backward
      */
     backwardVisibleLines(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_visible_lines", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: count,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves backward to the previous visible word start.
@@ -451,34 +492,39 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Calls {@link Gtk.TextIter.backward_visible_word_start} up to `count` times.
-     * @param count - number of times to move
-     */
+    /** Calls {@link Gtk.TextIter.backward_visible_word_start} up to `count` times. */
     backwardVisibleWordStarts(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_visible_word_starts", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: count,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves backward to the previous word start.
@@ -494,34 +540,39 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Calls {@link Gtk.TextIter.backward_word_start} up to `count` times.
-     * @param count - number of times to move
-     */
+    /** Calls {@link Gtk.TextIter.backward_word_start} up to `count` times. */
     backwardWordStarts(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_word_starts", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: count,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Considering the default editability of the buffer, and tags that
@@ -532,24 +583,27 @@ export class TextIter extends NativeObject {
      * user should be allowed to insert text at `iter`.
      * {@link Gtk.TextBuffer.insert_interactive} uses this function
      * to decide whether insertions are allowed at a given position.
-     * @param defaultEditability - %TRUE if text is editable by default
      */
     canInsert(defaultEditability) {
         return call("libgtk-4.so.1", "gtk_text_iter_can_insert", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: defaultEditability,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * A qsort()-style function that returns negative if `lhs` is less than
@@ -557,14 +611,13 @@ export class TextIter extends NativeObject {
      *
      * Ordering is in character offset order, i.e. the first character
      * in the buffer is less than the second character in the buffer.
-     * @param rhs - another `GtkTextIter`
      */
     compare(rhs) {
         return call("libgtk-4.so.1", "gtk_text_iter_compare", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
@@ -573,14 +626,18 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_text_iter_get_type",
                 },
-                value: rhs?.id ?? rhs,
+                value: rhs.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Creates a dynamically-allocated copy of an iterator.
@@ -596,7 +653,7 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
@@ -604,7 +661,7 @@ export class TextIter extends NativeObject {
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "GtkTextIter",
             lib: "libgtk-4.so.1",
             getTypeFn: "gtk_text_iter_get_type",
@@ -625,24 +682,27 @@ export class TextIter extends NativeObject {
      * know whether a new character inserted at `iter` would be inside an
      * editable range. Use {@link Gtk.TextIter.can_insert} to handle this
      * case.
-     * @param defaultSetting - %TRUE if text is editable by default
      */
     editable(defaultSetting) {
         return call("libgtk-4.so.1", "gtk_text_iter_editable", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: defaultSetting,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Returns %TRUE if `iter` points to the start of the paragraph
@@ -662,13 +722,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Determines whether `iter` ends a sentence.
@@ -681,13 +743,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Returns %TRUE if `tag` is toggled off at exactly this point.
@@ -700,25 +764,29 @@ export class TextIter extends NativeObject {
      * unlike {@link Gtk.TextIter.starts_tag}, if this function
      * returns %TRUE, {@link Gtk.TextIter.has_tag} will return
      * %FALSE for the same parameters.
-     * @param tag - a `GtkTextTag`
      */
     endsTag(tag) {
         return call("libgtk-4.so.1", "gtk_text_iter_ends_tag", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: tag?.id ?? tag,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: tag?.id,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Determines whether `iter` ends a natural-language word.
@@ -731,13 +799,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Tests whether two iterators are equal, using the fastest possible
@@ -747,14 +817,13 @@ export class TextIter extends NativeObject {
      * better than e.g. getting the character offset for each
      * iterator and comparing the offsets yourself. Also, it’s a
      * bit faster than {@link Gtk.TextIter.compare}.
-     * @param rhs - another `GtkTextIter`
      */
     equal(rhs) {
         return call("libgtk-4.so.1", "gtk_text_iter_equal", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
@@ -763,14 +832,16 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_text_iter_get_type",
                 },
-                value: rhs?.id ?? rhs,
+                value: rhs.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `iter` forward by one character offset.
@@ -786,13 +857,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `count` characters if possible.
@@ -804,24 +877,29 @@ export class TextIter extends NativeObject {
      * `iter` is different from its original position, and dereferenceable
      * (the last iterator in the buffer is not dereferenceable). If `count`
      * is 0, the function does nothing and returns %FALSE.
-     * @param count - number of characters to move, may be negative
      */
     forwardChars(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_chars", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: count,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `iter` forward by a single cursor position.
@@ -845,36 +923,43 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves up to `count` cursor positions.
      *
      * See {@link Gtk.TextIter.forward_cursor_position} for details.
-     * @param count - number of positions to move
      */
     forwardCursorPositions(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_cursor_positions", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: count,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `iter` to the start of the next line.
@@ -889,13 +974,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `count` lines forward, if possible.
@@ -908,24 +995,29 @@ export class TextIter extends NativeObject {
      * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
      * the function does nothing and returns %FALSE. If `count` is negative,
      * moves backward by 0 - `count` lines.
-     * @param count - number of lines to move forward
      */
     forwardLines(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_lines", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: count,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Searches forward for `str`.
@@ -938,65 +1030,69 @@ export class TextIter extends NativeObject {
      *
      * `match_start` will never be set to a `GtkTextIter` located before `iter`,
      * even if there is a possible `match_end` after or at `iter`.
-     * @param str - a search string
-     * @param flags - flags affecting how the search is done
-     * @param matchStart - return location for start of match
-     * @param matchEnd - return location for end of match
-     * @param limit - location of last possible `match_end`, or %NULL for the end of the buffer
      */
     forwardSearch(str, flags, matchStart, matchEnd, limit) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_search", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: str,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: flags,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_text_iter_get_type",
                 },
-                value: matchStart?.id ?? matchStart,
+                value: matchStart?.id,
                 optional: true,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_text_iter_get_type",
                 },
-                value: matchEnd?.id ?? matchEnd,
+                value: matchEnd?.id,
                 optional: true,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_text_iter_get_type",
                 },
-                value: limit?.id ?? limit,
+                value: limit?.id,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves forward to the next sentence end.
@@ -1012,36 +1108,43 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Calls {@link Gtk.TextIter.forward_sentence_end} `count` times.
      *
      * If `count` is negative, moves backward instead of forward.
-     * @param count - number of sentences to move
      */
     forwardSentenceEnds(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_sentence_ends", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: count,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `iter` forward to the “end iterator”, which points
@@ -1055,13 +1158,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Moves the iterator to point to the paragraph delimiter characters.
@@ -1081,13 +1186,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves forward to the next toggle (on or off) of the
@@ -1099,25 +1206,29 @@ export class TextIter extends NativeObject {
      * located at `iter`, only toggles after `iter`. Sets `iter` to
      * the location of the toggle, or to the end of the buffer
      * if no toggle is found.
-     * @param tag - a `GtkTextTag`
      */
     forwardToTagToggle(tag) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_to_tag_toggle", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: tag?.id ?? tag,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: tag?.id,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `iter` forward to the next visible cursor position.
@@ -1129,36 +1240,43 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves up to `count` visible cursor positions.
      *
      * See {@link Gtk.TextIter.forward_cursor_position} for details.
-     * @param count - number of positions to move
      */
     forwardVisibleCursorPositions(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_visible_cursor_positions", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: count,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `iter` to the start of the next visible line.
@@ -1173,13 +1291,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves `count` visible lines forward, if possible.
@@ -1192,24 +1312,29 @@ export class TextIter extends NativeObject {
      * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
      * the function does nothing and returns %FALSE. If `count` is negative,
      * moves backward by 0 - `count` lines.
-     * @param count - number of lines to move forward
      */
     forwardVisibleLines(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_visible_lines", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: count,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves forward to the next visible word end.
@@ -1225,34 +1350,39 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Calls {@link Gtk.TextIter.forward_visible_word_end} up to `count` times.
-     * @param count - number of times to move
-     */
+    /** Calls {@link Gtk.TextIter.forward_visible_word_end} up to `count` times. */
     forwardVisibleWordEnds(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_visible_word_ends", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: count,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Moves forward to the next word end.
@@ -1268,34 +1398,39 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Calls {@link Gtk.TextIter.forward_word_end} up to `count` times.
-     * @param count - number of times to move
-     */
+    /** Calls {@link Gtk.TextIter.forward_word_end} up to `count` times. */
     forwardWordEnds(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_word_ends", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: count,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Free an iterator allocated on the heap.
@@ -1309,29 +1444,32 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
-    /**
-     * Returns the `GtkTextBuffer` this iterator is associated with.
-     */
+    /** Returns the `GtkTextBuffer` this iterator is associated with. */
     getBuffer() {
         const ptr = call("libgtk-4.so.1", "gtk_text_iter_get_buffer", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         return getNativeObject(ptr);
     }
     /**
@@ -1343,13 +1481,17 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * The Unicode character at this iterator is returned.
@@ -1367,13 +1509,17 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
     /**
      * Returns the number of characters in the line containing `iter`,
@@ -1384,13 +1530,17 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * If the location at `iter` contains a child anchor, the
@@ -1403,13 +1553,16 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
@@ -1425,7 +1578,7 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
@@ -1433,7 +1586,7 @@ export class TextIter extends NativeObject {
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "PangoLanguage",
             lib: "libpango-1.0.so.0",
             getTypeFn: "pango_language_get_type",
@@ -1451,13 +1604,17 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Returns the byte index of the iterator, counting
@@ -1472,13 +1629,17 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Returns the character offset of the iterator,
@@ -1491,13 +1652,17 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Returns a list of all `GtkTextMark` at this location.
@@ -1509,11 +1674,11 @@ export class TextIter extends NativeObject {
      * The returned list is not in any meaningful order.
      */
     getMarks() {
-        const ptrs = call("libgtk-4.so.1", "gtk_text_iter_get_marks", [
+        const arr = call("libgtk-4.so.1", "gtk_text_iter_get_marks", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
@@ -1521,11 +1686,14 @@ export class TextIter extends NativeObject {
             },
         ], {
             type: "array",
-            itemType: { type: "gobject", borrowed: true },
+            itemType: {
+                type: "gobject",
+                ownership: "none",
+            },
             listType: "gslist",
-            borrowed: true,
+            ownership: "none",
         });
-        return ptrs.map((ptr) => getNativeObject(ptr));
+        return arr.map((item) => getNativeObject(item));
     }
     /**
      * Returns the character offset of an iterator.
@@ -1540,13 +1708,17 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * If the element at `iter` is a paintable, the paintable is returned.
@@ -1558,13 +1730,16 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr, Gdk.Paintable);
@@ -1580,14 +1755,13 @@ export class TextIter extends NativeObject {
      * offsets in the text buffer. Note that 0xFFFC can occur in normal
      * text as well, so it is not a reliable indicator that a paintable or
      * widget is in the buffer.
-     * @param end - iterator at end of a range
      */
     getSlice(end) {
         return call("libgtk-4.so.1", "gtk_text_iter_get_slice", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
@@ -1596,14 +1770,17 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_text_iter_get_type",
                 },
-                value: end?.id ?? end,
+                value: end.id,
             },
-        ], { type: "string" });
+        ], {
+            type: "string",
+            ownership: "full",
+        });
     }
     /**
      * Returns a list of tags that apply to `iter`, in ascending order of
@@ -1615,11 +1792,11 @@ export class TextIter extends NativeObject {
      * but you have to free the list itself.
      */
     getTags() {
-        const ptrs = call("libgtk-4.so.1", "gtk_text_iter_get_tags", [
+        const arr = call("libgtk-4.so.1", "gtk_text_iter_get_tags", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
@@ -1627,11 +1804,14 @@ export class TextIter extends NativeObject {
             },
         ], {
             type: "array",
-            itemType: { type: "gobject", borrowed: true },
+            itemType: {
+                type: "gobject",
+                ownership: "none",
+            },
             listType: "gslist",
-            borrowed: true,
+            ownership: "none",
         });
-        return ptrs.map((ptr) => getNativeObject(ptr));
+        return arr.map((item) => getNativeObject(item));
     }
     /**
      * Returns text in the given range.
@@ -1641,14 +1821,13 @@ export class TextIter extends NativeObject {
      * offsets in the returned string will not correspond to character and
      * byte offsets in the buffer. If you want offsets to correspond, see
      * {@link Gtk.TextIter.get_slice}.
-     * @param end - iterator at end of a range
      */
     getText(end) {
         return call("libgtk-4.so.1", "gtk_text_iter_get_text", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
@@ -1657,14 +1836,17 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_text_iter_get_type",
                 },
-                value: end?.id ?? end,
+                value: end.id,
             },
-        ], { type: "string" });
+        ], {
+            type: "string",
+            ownership: "full",
+        });
     }
     /**
      * Returns a list of `GtkTextTag` that are toggled on or off at this
@@ -1675,30 +1857,34 @@ export class TextIter extends NativeObject {
      * range of characters following `iter` has that tag applied to it.  If
      * a tag is toggled off, then some non-empty range following `iter`
      * does not have the tag applied to it.
-     * @param toggledOn - %TRUE to get toggled-on tags
      */
     getToggledTags(toggledOn) {
-        const ptrs = call("libgtk-4.so.1", "gtk_text_iter_get_toggled_tags", [
+        const arr = call("libgtk-4.so.1", "gtk_text_iter_get_toggled_tags", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: toggledOn,
             },
         ], {
             type: "array",
-            itemType: { type: "gobject", borrowed: true },
+            itemType: {
+                type: "gobject",
+                ownership: "none",
+            },
             listType: "gslist",
-            borrowed: true,
+            ownership: "none",
         });
-        return ptrs.map((ptr) => getNativeObject(ptr));
+        return arr.map((item) => getNativeObject(item));
     }
     /**
      * Returns the number of bytes from the start of the
@@ -1711,13 +1897,17 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Returns the offset in characters from the start of the
@@ -1730,13 +1920,17 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Returns visible text in the given range.
@@ -1745,14 +1939,13 @@ export class TextIter extends NativeObject {
      * is not included. Invisible text is usually invisible because
      * a `GtkTextTag` with the “invisible” attribute turned on has
      * been applied to it.
-     * @param end - iterator at end of range
      */
     getVisibleSlice(end) {
         return call("libgtk-4.so.1", "gtk_text_iter_get_visible_slice", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
@@ -1761,14 +1954,17 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_text_iter_get_type",
                 },
-                value: end?.id ?? end,
+                value: end.id,
             },
-        ], { type: "string" });
+        ], {
+            type: "string",
+            ownership: "full",
+        });
     }
     /**
      * Returns visible text in the given range.
@@ -1777,14 +1973,13 @@ export class TextIter extends NativeObject {
      * is not included. Invisible text is usually invisible because
      * a `GtkTextTag` with the “invisible” attribute turned on has
      * been applied to it.
-     * @param end - iterator at end of range
      */
     getVisibleText(end) {
         return call("libgtk-4.so.1", "gtk_text_iter_get_visible_text", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
@@ -1793,14 +1988,17 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_text_iter_get_type",
                 },
-                value: end?.id ?? end,
+                value: end.id,
             },
-        ], { type: "string" });
+        ], {
+            type: "string",
+            ownership: "full",
+        });
     }
     /**
      * Returns %TRUE if `iter` points to a character that is part
@@ -1808,38 +2006,40 @@ export class TextIter extends NativeObject {
      *
      * See also {@link Gtk.TextIter.starts_tag} and
      * {@link Gtk.TextIter.ends_tag}.
-     * @param tag - a `GtkTextTag`
      */
     hasTag(tag) {
         return call("libgtk-4.so.1", "gtk_text_iter_has_tag", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: tag?.id ?? tag,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: tag.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Checks whether `iter` falls in the range [`start`, `end`).
      *
      * `start` and `end` must be in ascending order.
-     * @param start - start of range
-     * @param end - end of range
      */
     inRange(start, end) {
         return call("libgtk-4.so.1", "gtk_text_iter_in_range", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
@@ -1848,24 +2048,26 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_text_iter_get_type",
                 },
-                value: start?.id ?? start,
+                value: start.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_text_iter_get_type",
                 },
-                value: end?.id ?? end,
+                value: end.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Determines whether `iter` is inside a sentence (as opposed to in
@@ -1880,13 +2082,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Determines whether the character pointed by `iter` is part of a
@@ -1904,13 +2108,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Determine if `iter` is at a cursor position.
@@ -1924,13 +2130,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Returns %TRUE if `iter` is the end iterator.
@@ -1944,29 +2152,31 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Returns %TRUE if `iter` is the first iterator in the buffer.
-     */
+    /** Returns %TRUE if `iter` is the first iterator in the buffer. */
     isStart() {
         return call("libgtk-4.so.1", "gtk_text_iter_is_start", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Swaps the value of `first` and `second` if `second` comes before
@@ -1978,14 +2188,13 @@ export class TextIter extends NativeObject {
      * call it yourself in those cases. There are some exceptions,
      * such as {@link Gtk.TextIter.in_range}, that expect a
      * pre-sorted range.
-     * @param second - another `GtkTextIter`
      */
     order(second) {
         call("libgtk-4.so.1", "gtk_text_iter_order", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
@@ -1994,62 +2203,74 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                     getTypeFn: "gtk_text_iter_get_type",
                 },
-                value: second?.id ?? second,
+                value: second.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Moves iterator `iter` to the start of the line `line_number`.
      *
      * If `line_number` is negative or larger than or equal to the number of lines
      * in the buffer, moves `iter` to the start of the last line in the buffer.
-     * @param lineNumber - line number (counted from 0)
      */
     setLine(lineNumber) {
         call("libgtk-4.so.1", "gtk_text_iter_set_line", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: lineNumber,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Same as {@link Gtk.TextIter.set_line_offset}, but works with a
      * byte index. The given byte index must be at
      * the start of a character, it can’t be in the middle of a UTF-8
      * encoded character.
-     * @param byteOnLine - a byte index relative to the start of `iter`’s current line
      */
     setLineIndex(byteOnLine) {
         call("libgtk-4.so.1", "gtk_text_iter_set_line_index", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: byteOnLine,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Moves `iter` within a line, to a new character (not byte) offset.
@@ -2058,94 +2279,114 @@ export class TextIter extends NativeObject {
      * of characters in the line; if equal, `iter` moves to the start of the
      * next line. See {@link Gtk.TextIter.set_line_index} if you have a byte
      * index rather than a character offset.
-     * @param charOnLine - a character offset relative to the start of `iter`’s current line
      */
     setLineOffset(charOnLine) {
         call("libgtk-4.so.1", "gtk_text_iter_set_line_offset", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: charOnLine,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets `iter` to point to `char_offset`.
      *
      * `char_offset` counts from the start
      * of the entire text buffer, starting with 0.
-     * @param charOffset - a character number
      */
     setOffset(charOffset) {
         call("libgtk-4.so.1", "gtk_text_iter_set_offset", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: charOffset,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Like {@link Gtk.TextIter.set_line_index}, but the index is in visible
      * bytes, i.e. text with a tag making it invisible is not counted
      * in the index.
-     * @param byteOnLine - a byte index
      */
     setVisibleLineIndex(byteOnLine) {
         call("libgtk-4.so.1", "gtk_text_iter_set_visible_line_index", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: byteOnLine,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Like {@link Gtk.TextIter.set_line_offset}, but the offset is in visible
      * characters, i.e. text with a tag making it invisible is not
      * counted in the offset.
-     * @param charOnLine - a character offset
      */
     setVisibleLineOffset(charOnLine) {
         call("libgtk-4.so.1", "gtk_text_iter_set_visible_line_offset", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: charOnLine,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Returns %TRUE if `iter` begins a paragraph.
@@ -2161,13 +2402,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Determines whether `iter` begins a sentence.
@@ -2180,13 +2423,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Returns %TRUE if `tag` is toggled on at exactly this point.
@@ -2199,25 +2444,29 @@ export class TextIter extends NativeObject {
      * words, unlike {@link Gtk.TextIter.ends_tag}, if
      * this function returns %TRUE, {@link Gtk.TextIter.has_tag}
      * will also return %TRUE for the same parameters.
-     * @param tag - a `GtkTextTag`
      */
     startsTag(tag) {
         return call("libgtk-4.so.1", "gtk_text_iter_starts_tag", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: tag?.id ?? tag,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: tag?.id,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Determines whether `iter` begins a natural-language word.
@@ -2230,13 +2479,15 @@ export class TextIter extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Gets whether a range with `tag` applied to it begins
@@ -2244,25 +2495,29 @@ export class TextIter extends NativeObject {
      *
      * This is equivalent to (gtk_text_iter_starts_tag() ||
      * gtk_text_iter_ends_tag())
-     * @param tag - a `GtkTextTag`
      */
     togglesTag(tag) {
         return call("libgtk-4.so.1", "gtk_text_iter_toggles_tag", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GtkTextIter",
                     lib: "libgtk-4.so.1",
                 },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: tag?.id ?? tag,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: tag?.id,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
 }
 registerNativeClass(TextIter);