@gtkx/ffi 0.10.5 → 0.11.1

package/dist/generated/glib/variant.js

@@ -4,6 +4,7 @@ import { getNativeObject } from "../../native/object.js";
 import { NativeObject } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
 import { Bytes } from "./bytes.js";
+import { GError } from "./error.js";
 import { VariantType } from "./variant-type.js";
 /**
  * `GVariant` is a variant datatype; it can contain one or more values
@@ -254,46 +255,98 @@ import { VariantType } from "./variant-type.js";
 export class Variant extends NativeObject {
     static glibTypeName = "GVariant";
     static objectType = "gvariant";
-    constructor(...args) {
-        super();
-        const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
-        this.id = this.createPtr(_args);
-    }
     /**
-     * Creates a new boolean #GVariant instance -- either %TRUE or %FALSE.
-     * @param value - a #gboolean value
+     * Creates a new #GVariant array from `children`.
+     *
+     * `child_type` must be non-%NULL if `n_children` is zero.  Otherwise, the
+     * child type is determined by inspecting the first element of the
+     * `children` array.  If `child_type` is non-%NULL then it must be a
+     * definite type.
+     *
+     * The items of the array are taken from the `children` array.  No entry
+     * in the `children` array may be %NULL.
+     *
+     * All items in the array must have the same type, which must be the
+     * same as `child_type`, if given.
+     *
+     * If the `children` are floating references (see g_variant_ref_sink()), the
+     * new instance takes ownership of them as if via g_variant_ref_sink().
      */
-    static newBoolean(value) {
-        const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_boolean", [
+    constructor(nChildren, childType, children) {
+        super();
+        this.id = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_array", [
             {
-                type: { type: "boolean" },
-                value: value,
+                type: {
+                    type: "boxed",
+                    ownership: "none",
+                    innerType: "GVariantType",
+                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    getTypeFn: "g_variant_type_get_gtype",
+                },
+                value: childType?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "gvariant",
+                        ownership: "none",
+                    },
+                    listType: "array",
+                    ownership: "none",
+                },
+                value: children,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: nChildren,
+                optional: false,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GVariant",
             lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
             getTypeFn: "intern",
         });
+    }
+    /** Creates a new boolean #GVariant instance -- either %TRUE or %FALSE. */
+    static newBoolean(value) {
+        const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_boolean", [
+            {
+                type: {
+                    type: "boolean",
+                },
+                value: value,
+                optional: false,
+            },
+        ], {
+            type: "gvariant",
+            ownership: "none",
+        });
         return getNativeObject(ptr, Variant);
     }
-    /**
-     * Creates a new byte #GVariant instance.
-     * @param value - a #guint8 value
-     */
+    /** Creates a new byte #GVariant instance. */
     static newByte(value) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_byte", [
             {
-                type: { type: "int", size: 8, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 8,
+                    unsigned: true,
+                },
                 value: value,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
@@ -304,23 +357,26 @@ export class Variant extends NativeObject {
      *
      * The nul terminator character at the end of the string is stored in
      * the array.
-     * @param string - a normal
      */
     static newBytestring(string) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_bytestring", [
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 8, unsigned: true },
+                    itemType: {
+                        type: "int",
+                        size: 8,
+                        unsigned: true,
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: string,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
@@ -329,25 +385,34 @@ export class Variant extends NativeObject {
      * strings.
      *
      * If `length` is -1 then `strv` is %NULL-terminated.
-     * @param strv - an array of strings
-     * @param length - the length of `strv`, or -1
      */
     static newBytestringArray(strv, length) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_bytestring_array", [
             {
-                type: { type: "array", itemType: { type: "string", borrowed: true } },
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "string",
+                        ownership: "none",
+                    },
+                    listType: "array",
+                    ownership: "none",
+                },
                 value: strv,
+                optional: false,
             },
             {
-                type: { type: "int", size: 64, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: false,
+                },
                 value: length,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
@@ -357,44 +422,45 @@ export class Variant extends NativeObject {
      *
      * If the `key` or `value` are floating references (see g_variant_ref_sink()),
      * the new instance takes ownership of them as if via g_variant_ref_sink().
-     * @param key - a basic #GVariant, the key
-     * @param value - a #GVariant, the value
      */
     static newDictEntry(key, value) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_dict_entry", [
             {
-                type: { type: "gvariant" },
+                type: {
+                    type: "gvariant",
+                    ownership: "none",
+                },
                 value: key,
+                optional: false,
             },
             {
-                type: { type: "gvariant" },
+                type: {
+                    type: "gvariant",
+                    ownership: "none",
+                },
                 value: value,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
-    /**
-     * Creates a new double #GVariant instance.
-     * @param value - a #gdouble floating point value
-     */
+    /** Creates a new double #GVariant instance. */
     static newDouble(value) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_double", [
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: value,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
@@ -412,42 +478,50 @@ export class Variant extends NativeObject {
      * expectation.
      *
      * `n_elements` must be the length of the `elements` array.
-     * @param elementType - the #GVariantType of each element
-     * @param elements - a pointer to the fixed array of contiguous elements
-     * @param nElements - the number of elements
-     * @param elementSize - the size of each element
      */
     static newFixedArray(elementType, nElements, elementSize, elements) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_fixed_array", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GVariantType",
                     lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                     getTypeFn: "g_variant_type_get_gtype",
                 },
-                value: elementType?.id ?? elementType,
+                value: elementType.id,
+                optional: false,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: elements,
                 optional: true,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: nElements,
+                optional: false,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: elementSize,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
@@ -461,42 +535,41 @@ export class Variant extends NativeObject {
      * The data in `bytes` must be aligned appropriately for the `type` being loaded.
      * Otherwise this function will internally create a copy of the memory (since
      * GLib 2.60) or (in older versions) fail and exit the process.
-     * @param type - a #GVariantType
-     * @param bytes - a #GBytes
-     * @param trusted - if the contents of `bytes` are trusted
      */
     static newFromBytes(type, bytes, trusted) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_from_bytes", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GVariantType",
                     lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                     getTypeFn: "g_variant_type_get_gtype",
                 },
-                value: type?.id ?? type,
+                value: type.id,
+                optional: false,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GBytes",
                     lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                     getTypeFn: "g_bytes_get_type",
                 },
-                value: bytes?.id ?? bytes,
+                value: bytes.id,
+                optional: false,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: trusted,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
@@ -530,55 +603,70 @@ export class Variant extends NativeObject {
      * `type` being loaded. Otherwise this function will internally create a copy of
      * the memory (since GLib 2.60) or (in older versions) fail and exit the
      * process.
-     * @param type - a definite #GVariantType
-     * @param data - the serialized data
-     * @param size - the size of `data`
-     * @param trusted - %TRUE if `data` is definitely in normal form
-     * @param notify - function to call when `data` is no longer needed
-     * @param userData - data for `notify`
      */
     static newFromData(type, data, size, trusted, notify, userData) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_from_data", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GVariantType",
                     lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                     getTypeFn: "g_variant_type_get_gtype",
                 },
-                value: type?.id ?? type,
+                value: type.id,
+                optional: false,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 8, unsigned: true },
+                    itemType: {
+                        type: "int",
+                        size: 8,
+                        unsigned: true,
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: data,
+                optional: false,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: size,
+                optional: false,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: trusted,
+                optional: false,
             },
             {
-                type: { type: "callback", trampoline: "destroy" },
+                type: {
+                    type: "callback",
+                    trampoline: "destroy",
+                },
                 value: notify,
+                optional: false,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: userData,
                 optional: true,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
@@ -588,77 +676,75 @@ export class Variant extends NativeObject {
      * By convention, handles are indexes into an array of file descriptors
      * that are sent alongside a D-Bus message.  If you're not interacting
      * with D-Bus, you probably don't need them.
-     * @param value - a #gint32 value
      */
     static newHandle(value) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_handle", [
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: value,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
-    /**
-     * Creates a new int16 #GVariant instance.
-     * @param value - a #gint16 value
-     */
+    /** Creates a new int16 #GVariant instance. */
     static newInt16(value) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_int16", [
             {
-                type: { type: "int", size: 16, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 16,
+                    unsigned: false,
+                },
                 value: value,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
-    /**
-     * Creates a new int32 #GVariant instance.
-     * @param value - a #gint32 value
-     */
+    /** Creates a new int32 #GVariant instance. */
     static newInt32(value) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_int32", [
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: value,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
-    /**
-     * Creates a new int64 #GVariant instance.
-     * @param value - a #gint64 value
-     */
+    /** Creates a new int64 #GVariant instance. */
     static newInt64(value) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_int64", [
             {
-                type: { type: "int", size: 64, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: false,
+                },
                 value: value,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
@@ -673,33 +759,31 @@ export class Variant extends NativeObject {
      *
      * If `child` is a floating reference (see g_variant_ref_sink()), the new
      * instance takes ownership of `child`.
-     * @param childType - the #GVariantType of the child, or %NULL
-     * @param child - the child value, or %NULL
      */
     static newMaybe(childType, child) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_maybe", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GVariantType",
                     lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                     getTypeFn: "g_variant_type_get_gtype",
                 },
-                value: childType?.id ?? childType,
+                value: childType?.id,
                 optional: true,
             },
             {
-                type: { type: "gvariant" },
+                type: {
+                    type: "gvariant",
+                    ownership: "none",
+                },
                 value: child,
                 optional: true,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
@@ -707,20 +791,20 @@ export class Variant extends NativeObject {
      * Creates a D-Bus object path #GVariant with the contents of `object_path`.
      * `object_path` must be a valid D-Bus object path.  Use
      * g_variant_is_object_path() if you're not sure.
-     * @param objectPath - a normal C nul-terminated string
      */
     static newObjectPath(objectPath) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_object_path", [
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: objectPath,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
@@ -732,25 +816,34 @@ export class Variant extends NativeObject {
      * g_variant_is_object_path().
      *
      * If `length` is -1 then `strv` is %NULL-terminated.
-     * @param strv - an array of strings
-     * @param length - the length of `strv`, or -1
      */
     static newObjv(strv, length) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_objv", [
             {
-                type: { type: "array", itemType: { type: "string", borrowed: true } },
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "string",
+                        ownership: "none",
+                    },
+                    listType: "array",
+                    ownership: "none",
+                },
                 value: strv,
+                optional: false,
             },
             {
-                type: { type: "int", size: 64, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: false,
+                },
                 value: length,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
@@ -758,20 +851,20 @@ export class Variant extends NativeObject {
      * Creates a D-Bus type signature #GVariant with the contents of
      * `string`.  `string` must be a valid D-Bus type signature.  Use
      * g_variant_is_signature() if you're not sure.
-     * @param signature - a normal C nul-terminated string
      */
     static newSignature(signature) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_signature", [
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: signature,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
@@ -781,20 +874,20 @@ export class Variant extends NativeObject {
      * `string` must be valid UTF-8, and must not be %NULL. To encode
      * potentially-%NULL strings, use g_variant_new() with `ms` as the
      * format string.
-     * @param string - a normal UTF-8 nul-terminated string
      */
     static newString(string) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_string", [
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: string,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
@@ -803,25 +896,34 @@ export class Variant extends NativeObject {
      * strings.
      *
      * If `length` is -1 then `strv` is %NULL-terminated.
-     * @param strv - an array of strings
-     * @param length - the length of `strv`, or -1
      */
     static newStrv(strv, length) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_strv", [
             {
-                type: { type: "array", itemType: { type: "string", borrowed: true } },
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "string",
+                        ownership: "none",
+                    },
+                    listType: "array",
+                    ownership: "none",
+                },
                 value: strv,
+                optional: false,
             },
             {
-                type: { type: "int", size: 64, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: false,
+                },
                 value: length,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
@@ -834,82 +936,88 @@ export class Variant extends NativeObject {
      *
      * If the `children` are floating references (see g_variant_ref_sink()), the
      * new instance takes ownership of them as if via g_variant_ref_sink().
-     * @param children - the items to make the tuple out of
-     * @param nChildren - the length of `children`
      */
     static newTuple(children, nChildren) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_tuple", [
             {
-                type: { type: "array", itemType: { type: "gvariant" } },
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "gvariant",
+                        ownership: "none",
+                    },
+                    listType: "array",
+                    ownership: "none",
+                },
                 value: children,
+                optional: false,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: nChildren,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
-    /**
-     * Creates a new uint16 #GVariant instance.
-     * @param value - a #guint16 value
-     */
+    /** Creates a new uint16 #GVariant instance. */
     static newUint16(value) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_uint16", [
             {
-                type: { type: "int", size: 16, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 16,
+                    unsigned: true,
+                },
                 value: value,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
-    /**
-     * Creates a new uint32 #GVariant instance.
-     * @param value - a #guint32 value
-     */
+    /** Creates a new uint32 #GVariant instance. */
     static newUint32(value) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_uint32", [
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: value,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
-    /**
-     * Creates a new uint64 #GVariant instance.
-     * @param value - a #guint64 value
-     */
+    /** Creates a new uint64 #GVariant instance. */
     static newUint64(value) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_uint64", [
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: value,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
@@ -919,53 +1027,23 @@ export class Variant extends NativeObject {
      *
      * If `child` is a floating reference (see g_variant_ref_sink()), the new
      * instance takes ownership of `child`.
-     * @param value - a #GVariant instance
      */
     static newVariant(value) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_variant", [
             {
-                type: { type: "gvariant" },
+                type: {
+                    type: "gvariant",
+                    ownership: "none",
+                },
                 value: value,
+                optional: false,
             },
         ], {
-            type: "boxed",
-            borrowed: true,
-            innerType: "GVariant",
-            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-            getTypeFn: "intern",
+            type: "gvariant",
+            ownership: "none",
         });
         return getNativeObject(ptr, Variant);
     }
-    createPtr(_args) {
-        const [childType, children, nChildren] = _args;
-        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_new_array", [
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariantType",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                    getTypeFn: "g_variant_type_get_gtype",
-                },
-                value: childType?.id ?? childType,
-                optional: true,
-            },
-            {
-                type: { type: "array", itemType: { type: "gvariant" } },
-                value: children,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: nChildren,
-            },
-        ], { type: "boxed", borrowed: true, innerType: "GVariant" });
-    }
-    static fromPtr(ptr) {
-        const instance = Object.create(Variant.prototype);
-        instance.id = ptr;
-        return instance;
-    }
     /**
      * Determines if a given string is a valid D-Bus object path.  You
      * should ensure that a string is a valid D-Bus object path before
@@ -975,15 +1053,19 @@ export class Variant extends NativeObject {
      * sequences of characters separated by `/` characters.  Each sequence
      * must contain only the characters `[A-Z][a-z][0-9]_`.  No sequence
      * (including the one following the final `/` character) may be empty.
-     * @param string - a normal C nul-terminated string
      */
     static isObjectPath(string) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_is_object_path", [
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: string,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Determines if a given string is a valid D-Bus type signature.  You
@@ -992,15 +1074,19 @@ export class Variant extends NativeObject {
      *
      * D-Bus type signatures consist of zero or more definite #GVariantType
      * strings in sequence.
-     * @param string - a normal C nul-terminated string
      */
     static isSignature(string) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_is_signature", [
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: string,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Parses a #GVariant from a text representation.
@@ -1039,10 +1125,6 @@ export class Variant extends NativeObject {
      * There may be implementation specific restrictions on deeply nested values,
      * which would result in a %G_VARIANT_PARSE_ERROR_RECURSION error. #GVariant is
      * guaranteed to handle nesting up to at least 64 levels.
-     * @param type - a #GVariantType, or %NULL
-     * @param text - a string containing a GVariant in text form
-     * @param limit - a pointer to the end of `text`, or %NULL
-     * @param endptr - a location to store the end pointer, or %NULL
      */
     static parse(text, type, limit, endptr) {
         const error = { value: null };
@@ -1050,25 +1132,34 @@ export class Variant extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GVariantType",
                     lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                     getTypeFn: "g_variant_type_get_gtype",
                 },
-                value: type?.id ?? type,
+                value: type?.id,
                 optional: true,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: text,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: limit,
                 optional: true,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: endptr,
                 optional: true,
             },
@@ -1077,15 +1168,19 @@ export class Variant extends NativeObject {
                     type: "ref",
                     innerType: {
                         type: "boxed",
+                        ownership: "full",
                         innerType: "GError",
-                        lib: "libglib-2.0.so.0",
+                        lib: "libgobject-2.0.so.0",
                     },
                 },
                 value: error,
             },
-        ], { type: "gvariant" });
+        ], {
+            type: "gvariant",
+            ownership: "full",
+        });
         if (error.value !== null) {
-            throw new NativeError(error.value);
+            throw new NativeError(getNativeObject(error.value, GError));
         }
         return getNativeObject(ptr, Variant);
     }
@@ -1100,16 +1195,16 @@ export class Variant extends NativeObject {
      *
      * |[
      * unterminated string constant:
-     * (1, 2, 3, 'abc
-     * ^^^^
+     *   (1, 2, 3, 'abc
+     *             ^^^^
      * ]|
      *
      * or
      *
      * |[
      * unable to find a common type:
-     * [1, 2, 3, 'str']
-     * ^        ^^^^^
+     *   [1, 2, 3, 'str']
+     *    ^        ^^^^^
      * ]|
      *
      * The format of the message may change in a future version.
@@ -1119,35 +1214,45 @@ export class Variant extends NativeObject {
      * If `source_str` was not nul-terminated when you passed it to
      * g_variant_parse() then you must add nul termination before using this
      * function.
-     * @param error - a #GError from the #GVariantParseError domain
-     * @param sourceStr - the string that was given to the parser
      */
     static parseErrorPrintContext(error, sourceStr) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_parse_error_print_context", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GError",
                     lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                     getTypeFn: "g_error_get_type",
                 },
-                value: error?.id ?? error,
+                value: error.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: sourceStr,
             },
-        ], { type: "string" });
+        ], {
+            type: "string",
+            ownership: "full",
+        });
     }
     static parseErrorQuark() {
-        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_parse_error_quark", [], { type: "int", size: 32, unsigned: true });
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_parse_error_quark", [], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
     }
-    /**
-     * Same as g_variant_error_quark().
-     */
+    /** Same as g_variant_error_quark(). */
     static parserGetErrorQuark() {
-        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_parser_get_error_quark", [], { type: "int", size: 32, unsigned: true });
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_parser_get_error_quark", [], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
     }
     /**
      * Performs a byteswapping operation on the contents of `value`.  The
@@ -1172,14 +1277,15 @@ export class Variant extends NativeObject {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_byteswap", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "gvariant" });
+        ], {
+            type: "gvariant",
+            ownership: "full",
+        });
         return getNativeObject(ptr, Variant);
     }
     /**
@@ -1197,45 +1303,48 @@ export class Variant extends NativeObject {
      * This function is meant to be used by functions that wish to provide
      * varargs accessors to #GVariant values of uncertain values (eg:
      * g_variant_lookup() or g_menu_model_get_item_attribute()).
-     * @param formatString - a valid #GVariant format string
-     * @param copyOnly - %TRUE to ensure the format string makes deep copies
      */
     checkFormatString(formatString, copyOnly) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_check_format_string", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: formatString,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: copyOnly,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Classifies `value` according to its top-level type.
-     */
+    /** Classifies `value` according to its top-level type. */
     classify() {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_classify", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Compares `one` and `two`.
@@ -1257,52 +1366,66 @@ export class Variant extends NativeObject {
      *
      * If you only require an equality comparison, g_variant_equal() is more
      * general.
-     * @param two - a #GVariant instance of the same type
      */
     compare(two) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_compare", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
-                type: { type: "gvariant" },
+                type: {
+                    type: "gvariant",
+                    ownership: "none",
+                },
                 value: two,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Similar to g_variant_get_bytestring() except that instead of
      * returning a constant string, the string is duplicated.
      *
      * The return value must be freed using g_free().
-     * @param length - a pointer to a #gsize, to store
      */
     dupBytestring(length) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_dup_bytestring", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
                 },
                 value: length,
                 optional: true,
             },
-        ], { type: "array", itemType: { type: "int", size: 8, unsigned: true } });
+        ], {
+            type: "array",
+            itemType: {
+                type: "int",
+                size: 8,
+                unsigned: true,
+            },
+            listType: "array",
+            ownership: "full",
+        });
     }
     /**
      * Gets the contents of an array of array of bytes #GVariant.  This call
@@ -1315,28 +1438,37 @@ export class Variant extends NativeObject {
      *
      * For an empty array, `length` will be set to 0 and a pointer to a
      * %NULL pointer will be returned.
-     * @param length - the length of the result, or %NULL
      */
     dupBytestringArray(length) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_dup_bytestring_array", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
                 },
                 value: length,
                 optional: true,
             },
-        ], { type: "array", itemType: { type: "string" } });
+        ], {
+            type: "array",
+            itemType: {
+                type: "string",
+                ownership: "full",
+            },
+            listType: "array",
+            ownership: "full",
+        });
     }
     /**
      * Gets the contents of an array of object paths #GVariant.  This call
@@ -1349,28 +1481,37 @@ export class Variant extends NativeObject {
      *
      * For an empty array, `length` will be set to 0 and a pointer to a
      * %NULL pointer will be returned.
-     * @param length - the length of the result, or %NULL
      */
     dupObjv(length) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_dup_objv", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
                 },
                 value: length,
                 optional: true,
             },
-        ], { type: "array", itemType: { type: "string" } });
+        ], {
+            type: "array",
+            itemType: {
+                type: "string",
+                ownership: "full",
+            },
+            listType: "array",
+            ownership: "full",
+        });
     }
     /**
      * Similar to g_variant_get_string() except that instead of returning
@@ -1379,27 +1520,31 @@ export class Variant extends NativeObject {
      * The string will always be UTF-8 encoded.
      *
      * The return value must be freed using g_free().
-     * @param length - a pointer to a #gsize, to store the length
      */
     dupString(length) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_dup_string", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
                 },
                 value: length,
             },
-        ], { type: "string" });
+        ], {
+            type: "string",
+            ownership: "full",
+        });
     }
     /**
      * Gets the contents of an array of strings #GVariant.  This call
@@ -1412,52 +1557,63 @@ export class Variant extends NativeObject {
      *
      * For an empty array, `length` will be set to 0 and a pointer to a
      * %NULL pointer will be returned.
-     * @param length - the length of the result, or %NULL
      */
     dupStrv(length) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_dup_strv", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
                 },
                 value: length,
                 optional: true,
             },
-        ], { type: "array", itemType: { type: "string" } });
+        ], {
+            type: "array",
+            itemType: {
+                type: "string",
+                ownership: "full",
+            },
+            listType: "array",
+            ownership: "full",
+        });
     }
     /**
      * Checks if `one` and `two` have the same type and value.
      *
      * The types of `one` and `two` are #gconstpointer only to allow use of
      * this function with #GHashTable.  They must each be a #GVariant.
-     * @param two - a #GVariant instance
      */
     equal(two) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_equal", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
-                type: { type: "gvariant" },
+                type: {
+                    type: "gvariant",
+                    ownership: "none",
+                },
                 value: two,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Returns the boolean value of `value`.
@@ -1469,14 +1625,14 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_boolean", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Returns the byte value of `value`.
@@ -1488,14 +1644,16 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_byte", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 8, unsigned: true });
+        ], {
+            type: "int",
+            size: 8,
+            unsigned: true,
+        });
     }
     /**
      * Returns the string value of a #GVariant instance with an
@@ -1521,14 +1679,21 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_bytestring", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "array", itemType: { type: "int", size: 8, unsigned: true } });
+        ], {
+            type: "array",
+            itemType: {
+                type: "int",
+                size: 8,
+                unsigned: true,
+            },
+            listType: "array",
+            ownership: "none",
+        });
     }
     /**
      * Gets the contents of an array of array of bytes #GVariant.  This call
@@ -1541,28 +1706,37 @@ export class Variant extends NativeObject {
      *
      * For an empty array, `length` will be set to 0 and a pointer to a
      * %NULL pointer will be returned.
-     * @param length - the length of the result, or %NULL
      */
     getBytestringArray(length) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_bytestring_array", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
                 },
                 value: length,
                 optional: true,
             },
-        ], { type: "array", itemType: { type: "string" } });
+        ], {
+            type: "array",
+            itemType: {
+                type: "string",
+                ownership: "full",
+            },
+            listType: "array",
+            ownership: "none",
+        });
     }
     /**
      * Reads a child item out of a container #GVariant instance.  This
@@ -1588,24 +1762,28 @@ export class Variant extends NativeObject {
      * nesting up to at least 64 levels.
      *
      * This function is O(1).
-     * @param index_ - the index of the child to fetch
      */
     getChildValue(index_) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_child_value", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: index_,
             },
-        ], { type: "gvariant" });
+        ], {
+            type: "gvariant",
+            ownership: "full",
+        });
         return getNativeObject(ptr, Variant);
     }
     /**
@@ -1639,14 +1817,16 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_data", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
     /**
      * Returns a pointer to the serialized form of a #GVariant instance.
@@ -1658,16 +1838,14 @@ export class Variant extends NativeObject {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_data_as_bytes", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "GBytes",
             lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
             getTypeFn: "g_bytes_get_type",
@@ -1684,14 +1862,15 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_double", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "float", size: 64 });
+        ], {
+            type: "float",
+            size: 64,
+        });
     }
     /**
      * Returns the 32-bit signed integer value of `value`.
@@ -1707,14 +1886,16 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_handle", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Returns the 16-bit signed integer value of `value`.
@@ -1726,14 +1907,16 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_int16", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 16, unsigned: false });
+        ], {
+            type: "int",
+            size: 16,
+            unsigned: false,
+        });
     }
     /**
      * Returns the 32-bit signed integer value of `value`.
@@ -1745,14 +1928,16 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_int32", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Returns the 64-bit signed integer value of `value`.
@@ -1764,14 +1949,16 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_int64", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 64, unsigned: false });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: false,
+        });
     }
     /**
      * Given a maybe-typed #GVariant instance, extract its value.  If the
@@ -1781,14 +1968,15 @@ export class Variant extends NativeObject {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_maybe", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "gvariant" });
+        ], {
+            type: "gvariant",
+            ownership: "full",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr, Variant);
@@ -1824,14 +2012,15 @@ export class Variant extends NativeObject {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_normal_form", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "gvariant" });
+        ], {
+            type: "gvariant",
+            ownership: "full",
+        });
         return getNativeObject(ptr, Variant);
     }
     /**
@@ -1845,28 +2034,37 @@ export class Variant extends NativeObject {
      *
      * For an empty array, `length` will be set to 0 and a pointer to a
      * %NULL pointer will be returned.
-     * @param length - the length of the result, or %NULL
      */
     getObjv(length) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_objv", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
                 },
                 value: length,
                 optional: true,
             },
-        ], { type: "array", itemType: { type: "string" } });
+        ], {
+            type: "array",
+            itemType: {
+                type: "string",
+                ownership: "full",
+            },
+            listType: "array",
+            ownership: "none",
+        });
     }
     /**
      * Determines the number of bytes that would be required to store `value`
@@ -1885,14 +2083,16 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_size", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
     /**
      * Returns the string value of a #GVariant instance with a string
@@ -1913,28 +2113,32 @@ export class Variant extends NativeObject {
      * other than those three.
      *
      * The return value remains valid as long as `value` exists.
-     * @param length - a pointer to a #gsize,
      */
     getString(length) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_string", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
                 },
                 value: length,
                 optional: true,
             },
-        ], { type: "string", borrowed: true });
+        ], {
+            type: "string",
+            ownership: "none",
+        });
     }
     /**
      * Gets the contents of an array of strings #GVariant.  This call
@@ -1947,28 +2151,37 @@ export class Variant extends NativeObject {
      *
      * For an empty array, `length` will be set to 0 and a pointer to a
      * %NULL pointer will be returned.
-     * @param length - the length of the result, or %NULL
      */
     getStrv(length) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_strv", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
                 },
                 value: length,
                 optional: true,
             },
-        ], { type: "array", itemType: { type: "string" } });
+        ], {
+            type: "array",
+            itemType: {
+                type: "string",
+                ownership: "full",
+            },
+            listType: "array",
+            ownership: "none",
+        });
     }
     /**
      * Determines the type of `value`.
@@ -1980,16 +2193,14 @@ export class Variant extends NativeObject {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_type", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GVariantType",
             lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
             getTypeFn: "g_variant_type_get_gtype",
@@ -2005,14 +2216,15 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_type_string", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "string", borrowed: true });
+        ], {
+            type: "string",
+            ownership: "none",
+        });
     }
     /**
      * Returns the 16-bit unsigned integer value of `value`.
@@ -2024,14 +2236,16 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_uint16", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 16, unsigned: true });
+        ], {
+            type: "int",
+            size: 16,
+            unsigned: true,
+        });
     }
     /**
      * Returns the 32-bit unsigned integer value of `value`.
@@ -2043,14 +2257,16 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_uint32", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: true });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
     }
     /**
      * Returns the 64-bit unsigned integer value of `value`.
@@ -2062,14 +2278,16 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_uint64", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
     /**
      * Unboxes `value`.  The result is the #GVariant instance that was
@@ -2079,14 +2297,15 @@ export class Variant extends NativeObject {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_get_variant", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "gvariant" });
+        ], {
+            type: "gvariant",
+            ownership: "full",
+        });
         return getNativeObject(ptr, Variant);
     }
     /**
@@ -2104,30 +2323,30 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_hash", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: true });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
     }
-    /**
-     * Checks if `value` is a container.
-     */
+    /** Checks if `value` is a container. */
     isContainer() {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_is_container", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Checks whether `value` has a floating reference count.
@@ -2144,14 +2363,14 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_is_floating", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Checks if `value` is in normal form.
@@ -2172,41 +2391,38 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_is_normal_form", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Checks if a value has a type matching the provided type.
-     * @param type - a #GVariantType
-     */
+    /** Checks if a value has a type matching the provided type. */
     isOfType(type) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_is_of_type", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GVariantType",
                     lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                     getTypeFn: "g_variant_type_get_gtype",
                 },
-                value: type?.id ?? type,
+                value: type.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Looks up a value in a dictionary #GVariant.
@@ -2230,36 +2446,38 @@ export class Variant extends NativeObject {
      *
      * This function is currently implemented with a linear scan.  If you
      * plan to do many lookups then #GVariantDict may be more efficient.
-     * @param key - the key to look up in the dictionary
-     * @param expectedType - a #GVariantType, or %NULL
      */
     lookupValue(key, expectedType) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_lookup_value", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: key,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GVariantType",
                     lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                     getTypeFn: "g_variant_type_get_gtype",
                 },
-                value: expectedType?.id ?? expectedType,
+                value: expectedType?.id,
                 optional: true,
             },
-        ], { type: "gvariant" });
+        ], {
+            type: "gvariant",
+            ownership: "full",
+        });
         return getNativeObject(ptr, Variant);
     }
     /**
@@ -2279,14 +2497,16 @@ export class Variant extends NativeObject {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_n_children", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
     /**
      * Pretty-prints `value` in the format understood by g_variant_parse().
@@ -2295,40 +2515,41 @@ export class Variant extends NativeObject {
      *
      * If `type_annotate` is %TRUE, then type information is included in
      * the output.
-     * @param typeAnnotate - %TRUE if type information should be included in
      */
     print(typeAnnotate) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_print", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: typeAnnotate,
             },
-        ], { type: "string" });
+        ], {
+            type: "string",
+            ownership: "full",
+        });
     }
-    /**
-     * Increases the reference count of `value`.
-     */
+    /** Increases the reference count of `value`. */
     ref() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_ref", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "gvariant" });
+        ], {
+            type: "gvariant",
+            ownership: "full",
+        });
         return getNativeObject(ptr, Variant);
     }
     /**
@@ -2359,14 +2580,15 @@ export class Variant extends NativeObject {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_ref_sink", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "gvariant" });
+        ], {
+            type: "gvariant",
+            ownership: "full",
+        });
         return getNativeObject(ptr, Variant);
     }
     /**
@@ -2382,24 +2604,27 @@ export class Variant extends NativeObject {
      * machine might be different) its endianness must also be available.
      *
      * This function is approximately O(n) in the size of `data`.
-     * @param data - the location to store the serialized data at
      */
     store(data) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_store", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: data,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * If `value` is floating, sink it.  Otherwise, do nothing.
@@ -2439,14 +2664,15 @@ export class Variant extends NativeObject {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_take_ref", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "gvariant" });
+        ], {
+            type: "gvariant",
+            ownership: "full",
+        });
         return getNativeObject(ptr, Variant);
     }
     /**
@@ -2457,14 +2683,14 @@ export class Variant extends NativeObject {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_unref", [
             {
                 type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    type: "gvariant",
+                    ownership: "none",
                 },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
 }
 registerNativeClass(Variant);