@gtkx/ffi 0.10.5 → 0.11.0

package/dist/generated/gio/functions.js

@@ -4,6 +4,7 @@ import { getNativeObject } from "../../native/object.js";
 import { Resource } from "./resource.js";
 import { SettingsSchemaSource } from "./settings-schema-source.js";
 import { AppInfo } from "./app-info.js";
+import { AsyncResult } from "./async-result.js";
 import { DtlsClientConnection } from "./dtls-client-connection.js";
 import { DtlsServerConnection } from "./dtls-server-connection.js";
 import { File } from "./file.js";
@@ -26,15 +27,19 @@ import * as GLib from "../glib/index.js";
  *
  * It is an error to call this function with a non-UTF-8 `action_name`.
  * `action_name` must not be `NULL`.
- * @param actionName - a potential action name
  */
 export const actionNameIsValid = (actionName) => {
     return call("libgio-2.0.so.0", "g_action_name_is_valid", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: actionName,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
 /**
  * Parses a detailed action name into its separate name and target
@@ -67,24 +72,36 @@ export const actionNameIsValid = (actionName) => {
  * returned in `target_value`, as the `detailed_name` may not contain a target.
  *
  * If returned, the {@link GLib.Variant} in `target_value` is guaranteed to not be floating.
- * @param detailedName - a detailed action name
- * @param actionName - the action name
- * @param targetValue - the target value,
  */
 export const actionParseDetailedName = (detailedName, actionName, targetValue) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_action_parse_detailed_name", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: detailedName,
         },
         {
-            type: { type: "ref", innerType: { type: "string" } },
+            type: {
+                type: "ref",
+                innerType: {
+                    type: "string",
+                    ownership: "full",
+                },
+            },
             value: actionName,
             optional: true,
         },
         {
-            type: { type: "ref", innerType: { type: "gvariant" } },
+            type: {
+                type: "ref",
+                innerType: {
+                    type: "gvariant",
+                    ownership: "full",
+                },
+            },
             value: targetValue,
             optional: true,
         },
@@ -93,15 +110,18 @@ export const actionParseDetailedName = (detailedName, actionName, targetValue) =
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return result;
 };
@@ -116,21 +136,28 @@ export const actionParseDetailedName = (detailedName, actionName, targetValue) =
  *
  * See that function for the types of strings that will be printed by
  * this function.
- * @param actionName - a valid action name
- * @param targetValue - a {@link GLib.Variant} target value, or `NULL`
  */
 export const actionPrintDetailedName = (actionName, targetValue) => {
     return call("libgio-2.0.so.0", "g_action_print_detailed_name", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: actionName,
         },
         {
-            type: { type: "gvariant" },
+            type: {
+                type: "gvariant",
+                ownership: "none",
+            },
             value: targetValue,
             optional: true,
         },
-    ], { type: "string" });
+    ], {
+        type: "string",
+        ownership: "full",
+    });
 };
 /**
  * Creates a new {@link Gio.AppInfo} from the given information.
@@ -142,24 +169,31 @@ export const actionPrintDetailedName = (actionName, targetValue) => {
  * being swallowed by `Exec` key unquoting. See
  * the specification
  * for exact quoting rules.
- * @param commandline - the command line to use
- * @param applicationName - the application name, or `NULL` to use `commandline`
- * @param flags - flags that can specify details of the created {@link Gio.AppInfo}
  */
 export const appInfoCreateFromCommandline = (commandline, flags, applicationName) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_app_info_create_from_commandline", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: commandline,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: applicationName,
             optional: true,
         },
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: flags,
         },
         {
@@ -167,15 +201,19 @@ export const appInfoCreateFromCommandline = (commandline, flags, applicationName
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr, AppInfo);
 };
@@ -195,82 +233,154 @@ export const appInfoCreateFromCommandline = (commandline, flags, applicationName
  * set.
  */
 export const appInfoGetAll = () => {
-    return call("libgio-2.0.so.0", "g_app_info_get_all", [], {
+    const arr = call("libgio-2.0.so.0", "g_app_info_get_all", [], {
         type: "array",
-        itemType: { type: "gobject", borrowed: true },
+        itemType: {
+            type: "gobject",
+            ownership: "full",
+        },
         listType: "glist",
-        borrowed: true,
+        ownership: "full",
     });
+    return arr.map((item) => getNativeObject(item));
 };
 /**
  * Gets a list of all {@link Gio.AppInfo}s for a given content type,
  * including the recommended and fallback {@link Gio.AppInfo}s. See
  * {@link Gio.AppInfo.get_recommended_for_type} and
  * {@link Gio.AppInfo.get_fallback_for_type}.
- * @param contentType - the content type to find a {@link Gio.AppInfo} for
  */
 export const appInfoGetAllForType = (contentType) => {
-    return call("libgio-2.0.so.0", "g_app_info_get_all_for_type", [
+    const arr = call("libgio-2.0.so.0", "g_app_info_get_all_for_type", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: contentType,
         },
     ], {
         type: "array",
-        itemType: { type: "gobject", borrowed: true },
+        itemType: {
+            type: "gobject",
+            ownership: "full",
+        },
         listType: "glist",
-        borrowed: true,
+        ownership: "full",
     });
+    return arr.map((item) => getNativeObject(item));
 };
-/**
- * Gets the default {@link Gio.AppInfo} for a given content type.
- * @param contentType - the content type to find a {@link Gio.AppInfo} for
- * @param mustSupportUris - if `TRUE`, the {@link Gio.AppInfo} is expected to
- */
+/** Gets the default {@link Gio.AppInfo} for a given content type. */
 export const appInfoGetDefaultForType = (contentType, mustSupportUris) => {
     const ptr = call("libgio-2.0.so.0", "g_app_info_get_default_for_type", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: contentType,
         },
         {
-            type: { type: "boolean" },
+            type: {
+                type: "boolean",
+            },
             value: mustSupportUris,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (ptr === null)
         return null;
     return getNativeObject(ptr, AppInfo);
 };
+/**
+ * Asynchronously gets the default {@link Gio.AppInfo} for a given content
+ * type.
+ */
+export const appInfoGetDefaultForTypeAsync = (contentType, mustSupportUris, cancellable, callback) => {
+    const wrappedCallback = callback
+        ? (...args) => callback(getNativeObject(args[0]), getNativeObject(args[1], AsyncResult))
+        : null;
+    call("libgio-2.0.so.0", "g_app_info_get_default_for_type_async", [
+        {
+            type: {
+                type: "string",
+                ownership: "none",
+            },
+            value: contentType,
+        },
+        {
+            type: {
+                type: "boolean",
+            },
+            value: mustSupportUris,
+        },
+        {
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: cancellable?.id,
+            optional: true,
+        },
+        {
+            type: {
+                type: "callback",
+                trampoline: "asyncReady",
+                argTypes: [
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                ],
+            },
+            value: wrappedCallback,
+            optional: true,
+        },
+    ], {
+        type: "undefined",
+    });
+};
 /**
  * Finishes a default {@link Gio.AppInfo} lookup started by
  * {@link Gio.AppInfo.get_default_for_type_async}.
  *
  * If no #{@link Gio.AppInfo} is found, then `error` will be set to
  * {@link Gio.IOErrorEnum.NOT_FOUND}.
- * @param result - the async result
  */
 export const appInfoGetDefaultForTypeFinish = (result) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_app_info_get_default_for_type_finish", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: result?.id ?? result,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: result.id,
         },
         {
             type: {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr, AppInfo);
 };
@@ -279,48 +389,107 @@ export const appInfoGetDefaultForTypeFinish = (result) => {
  *
  * A URI scheme is the initial part of the URI, up to but not including the `:`.
  * For example, `http`, `ftp` or `sip`.
- * @param uriScheme - a string containing a URI scheme.
  */
 export const appInfoGetDefaultForUriScheme = (uriScheme) => {
     const ptr = call("libgio-2.0.so.0", "g_app_info_get_default_for_uri_scheme", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: uriScheme,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (ptr === null)
         return null;
     return getNativeObject(ptr, AppInfo);
 };
+/**
+ * Asynchronously gets the default application for handling URIs with
+ * the given URI scheme. A URI scheme is the initial part
+ * of the URI, up to but not including the `:`, e.g. `http`,
+ * `ftp` or `sip`.
+ */
+export const appInfoGetDefaultForUriSchemeAsync = (uriScheme, cancellable, callback) => {
+    const wrappedCallback = callback
+        ? (...args) => callback(getNativeObject(args[0]), getNativeObject(args[1], AsyncResult))
+        : null;
+    call("libgio-2.0.so.0", "g_app_info_get_default_for_uri_scheme_async", [
+        {
+            type: {
+                type: "string",
+                ownership: "none",
+            },
+            value: uriScheme,
+        },
+        {
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: cancellable?.id,
+            optional: true,
+        },
+        {
+            type: {
+                type: "callback",
+                trampoline: "asyncReady",
+                argTypes: [
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                ],
+            },
+            value: wrappedCallback,
+            optional: true,
+        },
+    ], {
+        type: "undefined",
+    });
+};
 /**
  * Finishes a default {@link Gio.AppInfo} lookup started by
  * {@link Gio.AppInfo.get_default_for_uri_scheme_async}.
  *
  * If no {@link Gio.AppInfo} is found, then `error` will be set to
  * {@link Gio.IOErrorEnum.NOT_FOUND}.
- * @param result - the async result
  */
 export const appInfoGetDefaultForUriSchemeFinish = (result) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_app_info_get_default_for_uri_scheme_finish", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: result?.id ?? result,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: result.id,
         },
         {
             type: {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr, AppInfo);
 };
@@ -328,20 +497,26 @@ export const appInfoGetDefaultForUriSchemeFinish = (result) => {
  * Gets a list of fallback {@link Gio.AppInfo}s for a given content type, i.e.
  * those applications which claim to support the given content type by MIME
  * type subclassing and not directly.
- * @param contentType - the content type to find a {@link Gio.AppInfo} for
  */
 export const appInfoGetFallbackForType = (contentType) => {
-    return call("libgio-2.0.so.0", "g_app_info_get_fallback_for_type", [
+    const arr = call("libgio-2.0.so.0", "g_app_info_get_fallback_for_type", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: contentType,
         },
     ], {
         type: "array",
-        itemType: { type: "gobject", borrowed: true },
+        itemType: {
+            type: "gobject",
+            ownership: "full",
+        },
         listType: "glist",
-        borrowed: true,
+        ownership: "full",
     });
+    return arr.map((item) => getNativeObject(item));
 };
 /**
  * Gets a list of recommended {@link Gio.AppInfo}s for a given content type,
@@ -351,20 +526,26 @@ export const appInfoGetFallbackForType = (contentType) => {
  * Note that the first application of the list is the last used one, i.e.
  * the last one for which {@link Gio.AppInfo.set_as_last_used_for_type} has
  * been called.
- * @param contentType - the content type to find a {@link Gio.AppInfo} for
  */
 export const appInfoGetRecommendedForType = (contentType) => {
-    return call("libgio-2.0.so.0", "g_app_info_get_recommended_for_type", [
+    const arr = call("libgio-2.0.so.0", "g_app_info_get_recommended_for_type", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: contentType,
         },
     ], {
         type: "array",
-        itemType: { type: "gobject", borrowed: true },
+        itemType: {
+            type: "gobject",
+            ownership: "full",
+        },
         listType: "glist",
-        borrowed: true,
+        ownership: "full",
     });
+    return arr.map((item) => getNativeObject(item));
 };
 /**
  * Utility function that launches the default application registered to handle
@@ -374,19 +555,23 @@ export const appInfoGetRecommendedForType = (contentType) => {
  * The D-Bus–activated applications don’t have to be started if your application
  * terminates too soon after this function. To prevent this, use
  * {@link Gio.AppInfo.launch_default_for_uri_async} instead.
- * @param uri - the uri to show
- * @param context - optional launch context
  */
 export const appInfoLaunchDefaultForUri = (uri, context) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_app_info_launch_default_for_uri", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: uri,
         },
         {
-            type: { type: "gobject", borrowed: true },
-            value: context?.id ?? context,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: context?.id,
             optional: true,
         },
         {
@@ -394,43 +579,110 @@ export const appInfoLaunchDefaultForUri = (uri, context) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return result;
 };
 /**
- * Finishes an asynchronous launch-default-for-uri operation.
- * @param result - the async result
+ * Async version of {@link Gio.AppInfo.launch_default_for_uri}.
+ *
+ * This version is useful if you are interested in receiving error information
+ * in the case where the application is sandboxed and the portal may present an
+ * application chooser dialog to the user.
+ *
+ * This is also useful if you want to be sure that the D-Bus–activated
+ * applications are really started before termination and if you are interested
+ * in receiving error information from their activation.
  */
+export const appInfoLaunchDefaultForUriAsync = (uri, context, cancellable, callback) => {
+    const wrappedCallback = callback
+        ? (...args) => callback(getNativeObject(args[0]), getNativeObject(args[1], AsyncResult))
+        : null;
+    call("libgio-2.0.so.0", "g_app_info_launch_default_for_uri_async", [
+        {
+            type: {
+                type: "string",
+                ownership: "none",
+            },
+            value: uri,
+        },
+        {
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: context?.id,
+            optional: true,
+        },
+        {
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: cancellable?.id,
+            optional: true,
+        },
+        {
+            type: {
+                type: "callback",
+                trampoline: "asyncReady",
+                argTypes: [
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                ],
+            },
+            value: wrappedCallback,
+            optional: true,
+        },
+    ], {
+        type: "undefined",
+    });
+};
+/** Finishes an asynchronous launch-default-for-uri operation. */
 export const appInfoLaunchDefaultForUriFinish = (result) => {
     const error = { value: null };
     const _result = call("libgio-2.0.so.0", "g_app_info_launch_default_for_uri_finish", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: result?.id ?? result,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: result.id,
         },
         {
             type: {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return _result;
 };
@@ -440,15 +692,146 @@ export const appInfoLaunchDefaultForUriFinish = (result) => {
  * {@link Gio.AppInfo.set_as_default_for_extension},
  * {@link Gio.AppInfo.add_supports_type} or
  * {@link Gio.AppInfo.remove_supports_type}.
- * @param contentType - a content type
  */
 export const appInfoResetTypeAssociations = (contentType) => {
     call("libgio-2.0.so.0", "g_app_info_reset_type_associations", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: contentType,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
+};
+/**
+ * Helper function for constructing #GAsyncInitable object. This is
+ * similar to g_object_newv() but also initializes the object asynchronously.
+ *
+ * When the initialization is finished, `callback` will be called. You can
+ * then call g_async_initable_new_finish() to get the new object and check
+ * for any errors.
+ */
+export const asyncInitableNewvAsync = (objectType, nParameters, parameters, ioPriority, cancellable, callback) => {
+    const wrappedCallback = callback
+        ? (...args) => callback(getNativeObject(args[0]), getNativeObject(args[1], AsyncResult))
+        : null;
+    call("libgio-2.0.so.0", "g_async_initable_newv_async", [
+        {
+            type: {
+                type: "int",
+                size: 64,
+                unsigned: true,
+            },
+            value: objectType,
+        },
+        {
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
+            value: nParameters,
+        },
+        {
+            type: {
+                type: "struct",
+                ownership: "none",
+                innerType: "Parameter",
+            },
+            value: parameters.id,
+        },
+        {
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
+            value: ioPriority,
+        },
+        {
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: cancellable?.id,
+            optional: true,
+        },
+        {
+            type: {
+                type: "callback",
+                trampoline: "asyncReady",
+                argTypes: [
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                ],
+            },
+            value: wrappedCallback,
+            optional: true,
+        },
+    ], {
+        type: "undefined",
+    });
+};
+/**
+ * Asynchronously connects to the message bus specified by `bus_type`.
+ *
+ * When the operation is finished, `callback` will be invoked. You can
+ * then call g_bus_get_finish() to get the result of the operation.
+ *
+ * This is an asynchronous failable function. See g_bus_get_sync() for
+ * the synchronous version.
+ */
+export const busGet = (busType, cancellable, callback) => {
+    const wrappedCallback = callback
+        ? (...args) => callback(getNativeObject(args[0]), getNativeObject(args[1], AsyncResult))
+        : null;
+    call("libgio-2.0.so.0", "g_bus_get", [
+        {
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
+            value: busType,
+        },
+        {
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: cancellable?.id,
+            optional: true,
+        },
+        {
+            type: {
+                type: "callback",
+                trampoline: "asyncReady",
+                argTypes: [
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                ],
+            },
+            value: wrappedCallback,
+            optional: true,
+        },
+    ], {
+        type: "undefined",
+    });
 };
 /**
  * Finishes an operation started with g_bus_get().
@@ -463,29 +846,35 @@ export const appInfoResetTypeAssociations = (contentType) => {
  *
  * Note that the returned #GDBusConnection object will (usually) have
  * the #GDBusConnection:exit-on-close property set to %TRUE.
- * @param res - a #GAsyncResult obtained from the #GAsyncReadyCallback passed
  */
 export const busGetFinish = (res) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_bus_get_finish", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: res?.id ?? res,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: res.id,
         },
         {
             type: {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr);
 };
@@ -508,19 +897,24 @@ export const busGetFinish = (res) => {
  *
  * Note that the returned #GDBusConnection object will (usually) have
  * the #GDBusConnection:exit-on-close property set to %TRUE.
- * @param busType - a #GBusType
- * @param cancellable - a #GCancellable or %NULL
  */
 export const busGetSync = (busType, cancellable) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_bus_get_sync", [
         {
-            type: { type: "int", size: 32, unsigned: false },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
             value: busType,
         },
         {
-            type: { type: "gobject", borrowed: true },
-            value: cancellable?.id ?? cancellable,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: cancellable?.id,
             optional: true,
         },
         {
@@ -528,123 +922,145 @@ export const busGetSync = (busType, cancellable) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr);
 };
 /**
  * Version of {@link Gio.bus_own_name_on_connection} using closures instead of
  * callbacks for easier binding in other languages.
- * @param connection - a bus connection
- * @param name - the well-known name to own
- * @param flags - a set of flags with ownership options
- * @param nameAcquiredClosure - closure to invoke when `name` is
- * @param nameLostClosure - closure to invoke when `name` is lost,
  */
 export const busOwnNameOnConnectionWithClosures = (connection, name, flags, nameAcquiredClosure, nameLostClosure) => {
     return call("libgio-2.0.so.0", "g_bus_own_name_on_connection_with_closures", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: connection?.id ?? connection,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: connection.id,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: name,
         },
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: flags,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GClosure",
                 lib: "libgobject-2.0.so.0",
                 getTypeFn: "g_closure_get_type",
             },
-            value: nameAcquiredClosure?.id ?? nameAcquiredClosure,
+            value: nameAcquiredClosure?.id,
             optional: true,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GClosure",
                 lib: "libgobject-2.0.so.0",
                 getTypeFn: "g_closure_get_type",
             },
-            value: nameLostClosure?.id ?? nameLostClosure,
+            value: nameLostClosure?.id,
             optional: true,
         },
-    ], { type: "int", size: 32, unsigned: true });
+    ], {
+        type: "int",
+        size: 32,
+        unsigned: true,
+    });
 };
 /**
  * Version of [func`Gio`.bus_own_name using closures instead of callbacks for
  * easier binding in other languages.
- * @param busType - the type of bus to own a name on
- * @param name - the well-known name to own
- * @param flags - a set of flags with ownership options
- * @param busAcquiredClosure - closure to invoke when connected to
- * @param nameAcquiredClosure - closure to invoke when `name` is
- * @param nameLostClosure - closure to invoke when `name` is lost, or
  */
 export const busOwnNameWithClosures = (busType, name, flags, busAcquiredClosure, nameAcquiredClosure, nameLostClosure) => {
     return call("libgio-2.0.so.0", "g_bus_own_name_with_closures", [
         {
-            type: { type: "int", size: 32, unsigned: false },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
             value: busType,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: name,
         },
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: flags,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GClosure",
                 lib: "libgobject-2.0.so.0",
                 getTypeFn: "g_closure_get_type",
             },
-            value: busAcquiredClosure?.id ?? busAcquiredClosure,
+            value: busAcquiredClosure?.id,
             optional: true,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GClosure",
                 lib: "libgobject-2.0.so.0",
                 getTypeFn: "g_closure_get_type",
             },
-            value: nameAcquiredClosure?.id ?? nameAcquiredClosure,
+            value: nameAcquiredClosure?.id,
             optional: true,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GClosure",
                 lib: "libgobject-2.0.so.0",
                 getTypeFn: "g_closure_get_type",
             },
-            value: nameLostClosure?.id ?? nameLostClosure,
+            value: nameLostClosure?.id,
             optional: true,
         },
-    ], { type: "int", size: 32, unsigned: true });
+    ], {
+        type: "int",
+        size: 32,
+        unsigned: true,
+    });
 };
 /**
  * Stops owning a name.
@@ -656,15 +1072,20 @@ export const busOwnNameWithClosures = (busType, name, flags, busAcquiredClosure,
  * {@link GLib.DestroyNotify} function passed to {@link Gio.bus_own_name} is
  * called, in order to avoid memory leaks through callbacks queued on the
  * {@link GLib.MainContext} after it’s stopped being iterated.
- * @param ownerId - an identifier obtained from {@link Gio.bus_own_name}
  */
 export const busUnownName = (ownerId) => {
     call("libgio-2.0.so.0", "g_bus_unown_name", [
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: ownerId,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
 };
 /**
  * Stops watching a name.
@@ -675,163 +1096,201 @@ export const busUnownName = (ownerId) => {
  * until the #GDestroyNotify function passed to g_bus_watch_name() is called, in
  * order to avoid memory leaks through callbacks queued on the #GMainContext
  * after it’s stopped being iterated.
- * @param watcherId - An identifier obtained from g_bus_watch_name()
  */
 export const busUnwatchName = (watcherId) => {
     call("libgio-2.0.so.0", "g_bus_unwatch_name", [
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: watcherId,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
 };
 /**
  * Version of g_bus_watch_name_on_connection() using closures instead of callbacks for
  * easier binding in other languages.
- * @param connection - A #GDBusConnection.
- * @param name - The name (well-known or unique) to watch.
- * @param flags - Flags from the #GBusNameWatcherFlags enumeration.
- * @param nameAppearedClosure - #GClosure to invoke when `name` is known
- * @param nameVanishedClosure - #GClosure to invoke when `name` is known
  */
 export const busWatchNameOnConnectionWithClosures = (connection, name, flags, nameAppearedClosure, nameVanishedClosure) => {
     return call("libgio-2.0.so.0", "g_bus_watch_name_on_connection_with_closures", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: connection?.id ?? connection,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: connection.id,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: name,
         },
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: flags,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GClosure",
                 lib: "libgobject-2.0.so.0",
                 getTypeFn: "g_closure_get_type",
             },
-            value: nameAppearedClosure?.id ?? nameAppearedClosure,
+            value: nameAppearedClosure?.id,
             optional: true,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GClosure",
                 lib: "libgobject-2.0.so.0",
                 getTypeFn: "g_closure_get_type",
             },
-            value: nameVanishedClosure?.id ?? nameVanishedClosure,
+            value: nameVanishedClosure?.id,
             optional: true,
         },
-    ], { type: "int", size: 32, unsigned: true });
+    ], {
+        type: "int",
+        size: 32,
+        unsigned: true,
+    });
 };
 /**
  * Version of g_bus_watch_name() using closures instead of callbacks for
  * easier binding in other languages.
- * @param busType - The type of bus to watch a name on.
- * @param name - The name (well-known or unique) to watch.
- * @param flags - Flags from the #GBusNameWatcherFlags enumeration.
- * @param nameAppearedClosure - #GClosure to invoke when `name` is known
- * @param nameVanishedClosure - #GClosure to invoke when `name` is known
  */
 export const busWatchNameWithClosures = (busType, name, flags, nameAppearedClosure, nameVanishedClosure) => {
     return call("libgio-2.0.so.0", "g_bus_watch_name_with_closures", [
         {
-            type: { type: "int", size: 32, unsigned: false },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
             value: busType,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: name,
         },
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: flags,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GClosure",
                 lib: "libgobject-2.0.so.0",
                 getTypeFn: "g_closure_get_type",
             },
-            value: nameAppearedClosure?.id ?? nameAppearedClosure,
+            value: nameAppearedClosure?.id,
             optional: true,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GClosure",
                 lib: "libgobject-2.0.so.0",
                 getTypeFn: "g_closure_get_type",
             },
-            value: nameVanishedClosure?.id ?? nameVanishedClosure,
+            value: nameVanishedClosure?.id,
             optional: true,
         },
-    ], { type: "int", size: 32, unsigned: true });
+    ], {
+        type: "int",
+        size: 32,
+        unsigned: true,
+    });
 };
 /**
  * Checks if a content type can be executable. Note that for instance
  * things like text files can be executables (i.e. scripts and batch files).
- * @param type - a content type string
  */
 export const contentTypeCanBeExecutable = (type) => {
     return call("libgio-2.0.so.0", "g_content_type_can_be_executable", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: type,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
-/**
- * Compares two content types for equality.
- * @param type1 - a content type string
- * @param type2 - a content type string
- */
+/** Compares two content types for equality. */
 export const contentTypeEquals = (type1, type2) => {
     return call("libgio-2.0.so.0", "g_content_type_equals", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: type1,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: type2,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
-/**
- * Tries to find a content type based on the mime type name.
- * @param mimeType - a mime type string
- */
+/** Tries to find a content type based on the mime type name. */
 export const contentTypeFromMimeType = (mimeType) => {
     return call("libgio-2.0.so.0", "g_content_type_from_mime_type", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: mimeType,
         },
-    ], { type: "string" });
+    ], {
+        type: "string",
+        ownership: "full",
+    });
 };
-/**
- * Gets the human readable description of the content type.
- * @param type - a content type string
- */
+/** Gets the human readable description of the content type. */
 export const contentTypeGetDescription = (type) => {
     return call("libgio-2.0.so.0", "g_content_type_get_description", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: type,
         },
-    ], { type: "string" });
+    ], {
+        type: "string",
+        ownership: "full",
+    });
 };
 /**
  * Gets the generic icon name for a content type.
@@ -839,27 +1298,35 @@ export const contentTypeGetDescription = (type) => {
  * See the
  * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
  * specification for more on the generic icon name.
- * @param type - a content type string
  */
 export const contentTypeGetGenericIconName = (type) => {
     return call("libgio-2.0.so.0", "g_content_type_get_generic_icon_name", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: type,
         },
-    ], { type: "string" });
+    ], {
+        type: "string",
+        ownership: "full",
+    });
 };
-/**
- * Gets the icon for a content type.
- * @param type - a content type string
- */
+/** Gets the icon for a content type. */
 export const contentTypeGetIcon = (type) => {
     const ptr = call("libgio-2.0.so.0", "g_content_type_get_icon", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: type,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     return getNativeObject(ptr, Icon);
 };
 /**
@@ -869,32 +1336,43 @@ export const contentTypeGetIcon = (type) => {
 export const contentTypeGetMimeDirs = () => {
     return call("libgio-2.0.so.0", "g_content_type_get_mime_dirs", [], {
         type: "array",
-        itemType: { type: "string", borrowed: true },
+        itemType: {
+            type: "string",
+            ownership: "none",
+        },
+        listType: "array",
+        ownership: "none",
     });
 };
-/**
- * Gets the mime type for the content type, if one is registered.
- * @param type - a content type string
- */
+/** Gets the mime type for the content type, if one is registered. */
 export const contentTypeGetMimeType = (type) => {
     return call("libgio-2.0.so.0", "g_content_type_get_mime_type", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: type,
         },
-    ], { type: "string" });
+    ], {
+        type: "string",
+        ownership: "full",
+    });
 };
-/**
- * Gets the symbolic icon for a content type.
- * @param type - a content type string
- */
+/** Gets the symbolic icon for a content type. */
 export const contentTypeGetSymbolicIcon = (type) => {
     const ptr = call("libgio-2.0.so.0", "g_content_type_get_symbolic_icon", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: type,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     return getNativeObject(ptr, Icon);
 };
 /**
@@ -902,36 +1380,53 @@ export const contentTypeGetSymbolicIcon = (type) => {
  * uncertain, `result_uncertain` will be set to %TRUE. Either `filename`
  * or `data` may be %NULL, in which case the guess will be based solely
  * on the other argument.
- * @param filename - a path, or %NULL
- * @param data - a stream of data, or %NULL
- * @param dataSize - the size of `data`
- * @param resultUncertain - return location for the certainty
  */
 export const contentTypeGuess = (dataSize, filename, data, resultUncertain) => {
     return call("libgio-2.0.so.0", "g_content_type_guess", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: filename,
             optional: true,
         },
         {
             type: {
                 type: "array",
-                itemType: { type: "int", size: 8, unsigned: true },
+                itemType: {
+                    type: "int",
+                    size: 8,
+                    unsigned: true,
+                },
+                listType: "array",
+                ownership: "none",
             },
             value: data,
             optional: true,
         },
         {
-            type: { type: "int", size: 64, unsigned: true },
+            type: {
+                type: "int",
+                size: 64,
+                unsigned: true,
+            },
             value: dataSize,
         },
         {
-            type: { type: "ref", innerType: { type: "boolean" } },
+            type: {
+                type: "ref",
+                innerType: {
+                    type: "boolean",
+                },
+            },
             value: resultUncertain,
             optional: true,
         },
-    ], { type: "string" });
+    ], {
+        type: "string",
+        ownership: "full",
+    });
 };
 /**
  * Tries to guess the type of the tree with root `root`, by
@@ -946,72 +1441,96 @@ export const contentTypeGuess = (dataSize, filename, data, resultUncertain) => {
  *
  * This function is useful in the implementation of
  * g_mount_guess_content_type().
- * @param root - the root of the tree to guess a type for
  */
 export const contentTypeGuessForTree = (root) => {
     return call("libgio-2.0.so.0", "g_content_type_guess_for_tree", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: root?.id ?? root,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: root.id,
         },
-    ], { type: "array", itemType: { type: "string" } });
+    ], {
+        type: "array",
+        itemType: {
+            type: "string",
+            ownership: "full",
+        },
+        listType: "array",
+        ownership: "full",
+    });
 };
-/**
- * Determines if `type` is a subset of `supertype`.
- * @param type - a content type string
- * @param supertype - a content type string
- */
+/** Determines if `type` is a subset of `supertype`. */
 export const contentTypeIsA = (type, supertype) => {
     return call("libgio-2.0.so.0", "g_content_type_is_a", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: type,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: supertype,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
 /**
  * Determines if `type` is a subset of `mime_type`.
  * Convenience wrapper around g_content_type_is_a().
- * @param type - a content type string
- * @param mimeType - a mime type string
  */
 export const contentTypeIsMimeType = (type, mimeType) => {
     return call("libgio-2.0.so.0", "g_content_type_is_mime_type", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: type,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: mimeType,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
 /**
  * Checks if the content type is the generic "unknown" type.
  * On UNIX this is the "application/octet-stream" mimetype,
  * while on win32 it is "*" and on OSX it is a dynamic type
  * or octet-stream.
- * @param type - a content type string
  */
 export const contentTypeIsUnknown = (type) => {
     return call("libgio-2.0.so.0", "g_content_type_is_unknown", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: type,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
 /**
  * Set the list of directories used by GIO to load the MIME database.
  * If `dirs` is %NULL, the directories used are the default:
  *
- * - the `mime` subdirectory of the directory in `$XDG_DATA_HOME`
- * - the `mime` subdirectory of every directory in `$XDG_DATA_DIRS`
+ *  - the `mime` subdirectory of the directory in `$XDG_DATA_HOME`
+ *  - the `mime` subdirectory of every directory in `$XDG_DATA_DIRS`
  *
  * This function is intended to be used when writing tests that depend on
  * information stored in the MIME database, in order to control the data.
@@ -1021,25 +1540,34 @@ export const contentTypeIsUnknown = (type) => {
  * with `dirs` set to %NULL before calling g_test_init(), for instance:
  *
  * |[<!-- language="C" -->
- * // Load MIME data from the system
- * g_content_type_set_mime_dirs (NULL);
- * // Isolate the environment
- * g_test_init (&argc, &argv, G_TEST_OPTION_ISOLATE_DIRS, NULL);
+ *   // Load MIME data from the system
+ *   g_content_type_set_mime_dirs (NULL);
+ *   // Isolate the environment
+ *   g_test_init (&argc, &argv, G_TEST_OPTION_ISOLATE_DIRS, NULL);
  *
- * …
+ *   …
  *
- * return g_test_run ();
+ *   return g_test_run ();
  * ]|
- * @param dirs - %NULL-terminated list of
  */
 export const contentTypeSetMimeDirs = (dirs) => {
     call("libgio-2.0.so.0", "g_content_type_set_mime_dirs", [
         {
-            type: { type: "array", itemType: { type: "string", borrowed: true } },
+            type: {
+                type: "array",
+                itemType: {
+                    type: "string",
+                    ownership: "none",
+                },
+                listType: "array",
+                ownership: "none",
+            },
             value: dirs,
             optional: true,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
 };
 /**
  * Gets a list of strings containing all the registered content types
@@ -1049,9 +1577,12 @@ export const contentTypeSetMimeDirs = (dirs) => {
 export const contentTypesGetRegistered = () => {
     return call("libgio-2.0.so.0", "g_content_types_get_registered", [], {
         type: "array",
-        itemType: { type: "string" },
+        itemType: {
+            type: "string",
+            ownership: "full",
+        },
         listType: "glist",
-        borrowed: true,
+        ownership: "full",
     });
 };
 /**
@@ -1062,15 +1593,20 @@ export const contentTypesGetRegistered = () => {
  * this function would return `/run/bus-for-%3A0`,
  * which could be used in a D-Bus address like
  * `unix:nonce-tcp:host=127.0.0.1,port=42,noncefile=/run/bus-for-%3A0`.
- * @param string - an unescaped string to be included in a D-Bus address
  */
 export const dbusAddressEscapeValue = (string) => {
     return call("libgio-2.0.so.0", "g_dbus_address_escape_value", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: string,
         },
-    ], { type: "string" });
+    ], {
+        type: "string",
+        ownership: "full",
+    });
 };
 /**
  * Synchronously looks up the D-Bus address for the well-known message
@@ -1079,19 +1615,24 @@ export const dbusAddressEscapeValue = (string) => {
  *
  * The returned address will be in the
  * D-Bus address format.
- * @param busType - a #GBusType
- * @param cancellable - a #GCancellable or %NULL
  */
 export const dbusAddressGetForBusSync = (busType, cancellable) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_dbus_address_get_for_bus_sync", [
         {
-            type: { type: "int", size: 32, unsigned: false },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
             value: busType,
         },
         {
-            type: { type: "gobject", borrowed: true },
-            value: cancellable?.id ?? cancellable,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: cancellable?.id,
             optional: true,
         },
         {
@@ -1099,35 +1640,101 @@ export const dbusAddressGetForBusSync = (busType, cancellable) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "string" });
+    ], {
+        type: "string",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return result;
 };
+/**
+ * Asynchronously connects to an endpoint specified by `address` and
+ * sets up the connection so it is in a state to run the client-side
+ * of the D-Bus authentication conversation. `address` must be in the
+ * D-Bus address format.
+ *
+ * When the operation is finished, `callback` will be invoked. You can
+ * then call g_dbus_address_get_stream_finish() to get the result of
+ * the operation.
+ *
+ * This is an asynchronous failable function. See
+ * g_dbus_address_get_stream_sync() for the synchronous version.
+ */
+export const dbusAddressGetStream = (address, cancellable, callback) => {
+    const wrappedCallback = callback
+        ? (...args) => callback(getNativeObject(args[0]), getNativeObject(args[1], AsyncResult))
+        : null;
+    call("libgio-2.0.so.0", "g_dbus_address_get_stream", [
+        {
+            type: {
+                type: "string",
+                ownership: "none",
+            },
+            value: address,
+        },
+        {
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: cancellable?.id,
+            optional: true,
+        },
+        {
+            type: {
+                type: "callback",
+                trampoline: "asyncReady",
+                argTypes: [
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                ],
+            },
+            value: wrappedCallback,
+            optional: true,
+        },
+    ], {
+        type: "undefined",
+    });
+};
 /**
  * Finishes an operation started with g_dbus_address_get_stream().
  *
  * A server is not required to set a GUID, so `out_guid` may be set to %NULL
  * even on success.
- * @param res - A #GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_address_get_stream().
- * @param outGuid - %NULL or return location to store the GUID extracted from `address`, if any.
  */
 export const dbusAddressGetStreamFinish = (res, outGuid) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_dbus_address_get_stream_finish", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: res?.id ?? res,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: res.id,
         },
         {
-            type: { type: "ref", innerType: { type: "string" } },
+            type: {
+                type: "ref",
+                innerType: {
+                    type: "string",
+                    ownership: "full",
+                },
+            },
             value: outGuid,
             optional: true,
         },
@@ -1136,15 +1743,19 @@ export const dbusAddressGetStreamFinish = (res, outGuid) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr);
 };
@@ -1159,25 +1770,34 @@ export const dbusAddressGetStreamFinish = (res, outGuid) => {
  *
  * This is a synchronous failable function. See
  * g_dbus_address_get_stream() for the asynchronous version.
- * @param address - A valid D-Bus address.
- * @param outGuid - %NULL or return location to store the GUID extracted from `address`, if any.
- * @param cancellable - A #GCancellable or %NULL.
  */
 export const dbusAddressGetStreamSync = (address, outGuid, cancellable) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_dbus_address_get_stream_sync", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: address,
         },
         {
-            type: { type: "ref", innerType: { type: "string" } },
+            type: {
+                type: "ref",
+                innerType: {
+                    type: "string",
+                    ownership: "full",
+                },
+            },
             value: outGuid,
             optional: true,
         },
         {
-            type: { type: "gobject", borrowed: true },
-            value: cancellable?.id ?? cancellable,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: cancellable?.id,
             optional: true,
         },
         {
@@ -1185,15 +1805,19 @@ export const dbusAddressGetStreamSync = (address, outGuid, cancellable) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr);
 };
@@ -1201,8 +1825,6 @@ export const dbusAddressGetStreamSync = (address, outGuid, cancellable) => {
  * Looks up the value of an annotation.
  *
  * The cost of this function is O(n) in number of annotations.
- * @param annotations - A %NULL-terminated array of annotations or %NULL.
- * @param name - The name of the annotation to look up.
  */
 export const dbusAnnotationInfoLookup = (name, annotations) => {
     return call("libgio-2.0.so.0", "g_dbus_annotation_info_lookup", [
@@ -1211,19 +1833,28 @@ export const dbusAnnotationInfoLookup = (name, annotations) => {
                 type: "array",
                 itemType: {
                     type: "boxed",
+                    ownership: "none",
                     innerType: "GDBusAnnotationInfo",
                     lib: "libgio-2.0.so.0",
                     getTypeFn: "g_dbus_annotation_info_get_type",
                 },
+                listType: "array",
+                ownership: "none",
             },
             value: annotations,
             optional: true,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: name,
         },
-    ], { type: "string", borrowed: true });
+    ], {
+        type: "string",
+        ownership: "none",
+    });
 };
 /**
  * Creates a D-Bus error name to use for `error`.
@@ -1240,21 +1871,23 @@ export const dbusAnnotationInfoLookup = (name, annotations) => {
  *
  * This function is typically only used in object mappings to put a
  * {@link GLib.Error} on the wire. Regular applications should not use it.
- * @param error - an error
  */
 export const dbusErrorEncodeGerror = (error) => {
     return call("libgio-2.0.so.0", "g_dbus_error_encode_gerror", [
         {
             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: "string" });
+    ], {
+        type: "string",
+        ownership: "full",
+    });
 };
 /**
  * Gets the D-Bus error name used for `error`, if any.
@@ -1263,41 +1896,44 @@ export const dbusErrorEncodeGerror = (error) => {
  * {@link GLib.Error}s returned from functions handling remote method calls
  * (for example, {@link Gio.DBusConnection.call_finish}) unless
  * {@link Gio.DBusError.strip_remote_error} has already been used on `error`.
- * @param error - an error
  */
 export const dbusErrorGetRemoteError = (error) => {
     return call("libgio-2.0.so.0", "g_dbus_error_get_remote_error", [
         {
             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: "string" });
+    ], {
+        type: "string",
+        ownership: "full",
+    });
 };
 /**
  * Checks if `error` represents an error received via D-Bus from a remote peer.
  *
  * If so, use {@link Gio.DBusError.get_remote_error} to get the name of the error.
- * @param error - an error
  */
 export const dbusErrorIsRemoteError = (error) => {
     return call("libgio-2.0.so.0", "g_dbus_error_is_remote_error", [
         {
             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: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
 /**
  * Creates a {@link GLib.Error} based on the contents of `dbus_error_name` and
@@ -1329,22 +1965,26 @@ export const dbusErrorIsRemoteError = (error) => {
  * This function is typically only used in object mappings to prepare
  * {@link GLib.Error} instances for applications. Regular applications should not
  * use it.
- * @param dbusErrorName - D-Bus error name
- * @param dbusErrorMessage - D-Bus error message
  */
 export const dbusErrorNewForDbusError = (dbusErrorName, dbusErrorMessage) => {
     const ptr = call("libgio-2.0.so.0", "g_dbus_error_new_for_dbus_error", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: dbusErrorName,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: dbusErrorMessage,
         },
     ], {
         type: "boxed",
-        borrowed: true,
+        ownership: "full",
         innerType: "GError",
         lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
         getTypeFn: "g_error_get_type",
@@ -1364,25 +2004,35 @@ export const dbusErrorQuark = () => {
  *
  * This is typically done in the function that returns the {@link GLib.Quark} for
  * an error domain.
- * @param errorDomain - a {@link GLib.Quark} for an error domain
- * @param errorCode - an error code
- * @param dbusErrorName - a D-Bus error name
  */
 export const dbusErrorRegisterError = (errorDomain, errorCode, dbusErrorName) => {
     return call("libgio-2.0.so.0", "g_dbus_error_register_error", [
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: errorDomain,
         },
         {
-            type: { type: "int", size: 32, unsigned: false },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
             value: errorCode,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: dbusErrorName,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
 /**
  * Helper function for associating a {@link GLib.Error} error domain with D-Bus
@@ -1390,33 +2040,48 @@ export const dbusErrorRegisterError = (errorDomain, errorCode, dbusErrorName) =>
  *
  * While `quark_volatile` has a `volatile` qualifier, this is a historical
  * artifact and the argument passed to it should not be `volatile`.
- * @param errorDomainQuarkName - the error domain name
- * @param quarkVolatile - return location for the {@link GLib.Quark} representing the
- * @param entries - items to register
- * @param numEntries - number of items to register
  */
 export const dbusErrorRegisterErrorDomain = (errorDomainQuarkName, quarkVolatile, entries, numEntries) => {
     call("libgio-2.0.so.0", "g_dbus_error_register_error_domain", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: errorDomainQuarkName,
         },
         {
-            type: { type: "int", size: 64, unsigned: true },
+            type: {
+                type: "int",
+                size: 64,
+                unsigned: true,
+            },
             value: quarkVolatile,
         },
         {
             type: {
                 type: "array",
-                itemType: { type: "int", size: 64, unsigned: true },
+                itemType: {
+                    type: "struct",
+                    ownership: "none",
+                    innerType: "DBusErrorEntry",
+                },
+                listType: "array",
+                ownership: "none",
             },
             value: entries,
         },
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: numEntries,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
 };
 /**
  * Looks for extra information in the error message used to recover
@@ -1427,56 +2092,70 @@ export const dbusErrorRegisterErrorDomain = (errorDomainQuarkName, quarkVolatile
  * received on the wire.
  *
  * This is typically used when presenting errors to the end user.
- * @param error - an error
  */
 export const dbusErrorStripRemoteError = (error) => {
     return call("libgio-2.0.so.0", "g_dbus_error_strip_remote_error", [
         {
             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: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
 /**
  * Destroys an association previously set up with
  * {@link Gio.DBusError.register_error}.
- * @param errorDomain - a {@link GLib.Quark} for an error domain
- * @param errorCode - an error code
- * @param dbusErrorName - a D-Bus error name
  */
 export const dbusErrorUnregisterError = (errorDomain, errorCode, dbusErrorName) => {
     return call("libgio-2.0.so.0", "g_dbus_error_unregister_error", [
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: errorDomain,
         },
         {
-            type: { type: "int", size: 32, unsigned: false },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
             value: errorCode,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: dbusErrorName,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
-/**
- * This is a language binding friendly version of g_dbus_escape_object_path_bytestring().
- * @param s - the string to escape
- */
+/** This is a language binding friendly version of g_dbus_escape_object_path_bytestring(). */
 export const dbusEscapeObjectPath = (s) => {
     return call("libgio-2.0.so.0", "g_dbus_escape_object_path", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: s,
         },
-    ], { type: "string" });
+    ], {
+        type: "string",
+        ownership: "full",
+    });
 };
 /**
  * Escapes `bytes` for use in a D-Bus object path component.
@@ -1495,18 +2174,26 @@ export const dbusEscapeObjectPath = (s) => {
  * D-Bus object paths.
  *
  * This can be reversed with g_dbus_unescape_object_path().
- * @param bytes - the string of bytes to escape
  */
 export const dbusEscapeObjectPathBytestring = (bytes) => {
     return call("libgio-2.0.so.0", "g_dbus_escape_object_path_bytestring", [
         {
             type: {
                 type: "array",
-                itemType: { type: "int", size: 8, unsigned: true },
+                itemType: {
+                    type: "int",
+                    size: 8,
+                    unsigned: true,
+                },
+                listType: "array",
+                ownership: "none",
             },
             value: bytes,
         },
-    ], { type: "string" });
+    ], {
+        type: "string",
+        ownership: "full",
+    });
 };
 /**
  * Generate a D-Bus GUID that can be used with
@@ -1524,6 +2211,7 @@ export const dbusEscapeObjectPathBytestring = (bytes) => {
 export const dbusGenerateGuid = () => {
     return call("libgio-2.0.so.0", "g_dbus_generate_guid", [], {
         type: "string",
+        ownership: "full",
     });
 };
 /**
@@ -1555,32 +2243,33 @@ export const dbusGenerateGuid = () => {
  *
  * See the g_dbus_gvariant_to_gvalue() function for how to convert a
  * #GVariant to a #GValue.
- * @param gvalue - A #GValue to convert to a #GVariant
- * @param type - A #GVariantType
  */
 export const dbusGvalueToGvariant = (gvalue, type) => {
     const ptr = call("libgio-2.0.so.0", "g_dbus_gvalue_to_gvariant", [
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GValue",
                 lib: "libgobject-2.0.so.0",
                 getTypeFn: "g_value_get_type",
             },
-            value: gvalue?.id ?? gvalue,
+            value: gvalue.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: "gvariant" });
+    ], {
+        type: "gvariant",
+        ownership: "full",
+    });
     return getNativeObject(ptr, GLib.Variant);
 };
 /**
@@ -1595,26 +2284,29 @@ export const dbusGvalueToGvariant = (gvalue, type) => {
  *
  * The conversion never fails - a valid #GValue is always returned in
  * `out_gvalue`.
- * @param value - A #GVariant.
- * @param outGvalue - Return location pointing to a zero-filled (uninitialized) #GValue.
  */
 export const dbusGvariantToGvalue = (value, outGvalue) => {
     call("libgio-2.0.so.0", "g_dbus_gvariant_to_gvalue", [
         {
-            type: { type: "gvariant" },
+            type: {
+                type: "gvariant",
+                ownership: "none",
+            },
             value: value,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GValue",
                 lib: "libgobject-2.0.so.0",
                 getTypeFn: "g_value_get_type",
             },
-            value: outGvalue?.id ?? outGvalue,
+            value: outGvalue.id,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
 };
 /**
  * Checks if `string` is a
@@ -1623,15 +2315,19 @@ export const dbusGvariantToGvalue = (value, outGvalue) => {
  * This doesn't check if `string` is actually supported by #GDBusServer
  * or #GDBusConnection - use g_dbus_is_supported_address() to do more
  * checks.
- * @param string - A string.
  */
 export const dbusIsAddress = (string) => {
     return call("libgio-2.0.so.0", "g_dbus_is_address", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: string,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
 /**
  * Check whether `string` is a valid D-Bus error name.
@@ -1639,79 +2335,95 @@ export const dbusIsAddress = (string) => {
  * This function returns the same result as g_dbus_is_interface_name(),
  * because D-Bus error names are defined to have exactly the
  * same syntax as interface names.
- * @param string - The string to check.
  */
 export const dbusIsErrorName = (string) => {
     return call("libgio-2.0.so.0", "g_dbus_is_error_name", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: string,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
 /**
  * Checks if `string` is a D-Bus GUID.
  *
  * See the documentation for g_dbus_generate_guid() for more information about
  * the format of a GUID.
- * @param string - The string to check.
  */
 export const dbusIsGuid = (string) => {
     return call("libgio-2.0.so.0", "g_dbus_is_guid", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: string,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
-/**
- * Checks if `string` is a valid D-Bus interface name.
- * @param string - The string to check.
- */
+/** Checks if `string` is a valid D-Bus interface name. */
 export const dbusIsInterfaceName = (string) => {
     return call("libgio-2.0.so.0", "g_dbus_is_interface_name", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: string,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
-/**
- * Checks if `string` is a valid D-Bus member (e.g. signal or method) name.
- * @param string - The string to check.
- */
+/** Checks if `string` is a valid D-Bus member (e.g. signal or method) name. */
 export const dbusIsMemberName = (string) => {
     return call("libgio-2.0.so.0", "g_dbus_is_member_name", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: string,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
-/**
- * Checks if `string` is a valid D-Bus bus name (either unique or well-known).
- * @param string - The string to check.
- */
+/** Checks if `string` is a valid D-Bus bus name (either unique or well-known). */
 export const dbusIsName = (string) => {
     return call("libgio-2.0.so.0", "g_dbus_is_name", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: string,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
 /**
  * Like g_dbus_is_address() but also checks if the library supports the
  * transports in `string` and that key/value pairs for each transport
  * are valid. See the specification of the
  * D-Bus address format.
- * @param string - A string.
  */
 export const dbusIsSupportedAddress = (string) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_dbus_is_supported_address", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: string,
         },
         {
@@ -1719,29 +2431,34 @@ export const dbusIsSupportedAddress = (string) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return result;
 };
-/**
- * Checks if `string` is a valid D-Bus unique bus name.
- * @param string - The string to check.
- */
+/** Checks if `string` is a valid D-Bus unique bus name. */
 export const dbusIsUniqueName = (string) => {
     return call("libgio-2.0.so.0", "g_dbus_is_unique_name", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: string,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
 /**
  * Unescapes an string that was previously escaped with
@@ -1752,32 +2469,47 @@ export const dbusIsUniqueName = (string) => {
  * Encoding alphanumeric characters which do not need to be
  * encoded is not allowed (e.g `_63` is not valid, the string
  * should contain `c` instead).
- * @param s - the string to unescape
  */
 export const dbusUnescapeObjectPath = (s) => {
     return call("libgio-2.0.so.0", "g_dbus_unescape_object_path", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: s,
         },
-    ], { type: "array", itemType: { type: "int", size: 8, unsigned: true } });
+    ], {
+        type: "array",
+        itemType: {
+            type: "int",
+            size: 8,
+            unsigned: true,
+        },
+        listType: "array",
+        ownership: "none",
+    });
 };
 /**
  * Creates a new #GDtlsClientConnection wrapping `base_socket` which is
  * assumed to communicate with the server identified by `server_identity`.
- * @param baseSocket - the #GDatagramBased to wrap
- * @param serverIdentity - the expected identity of the server
  */
 export const dtlsClientConnectionNew = (baseSocket, serverIdentity) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_dtls_client_connection_new", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: baseSocket?.id ?? baseSocket,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: baseSocket.id,
         },
         {
-            type: { type: "gobject", borrowed: true },
-            value: serverIdentity?.id ?? serverIdentity,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: serverIdentity?.id,
             optional: true,
         },
         {
@@ -1785,33 +2517,39 @@ export const dtlsClientConnectionNew = (baseSocket, serverIdentity) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr, DtlsClientConnection);
 };
-/**
- * Creates a new #GDtlsServerConnection wrapping `base_socket`.
- * @param baseSocket - the #GDatagramBased to wrap
- * @param certificate - the default server certificate, or %NULL
- */
+/** Creates a new #GDtlsServerConnection wrapping `base_socket`. */
 export const dtlsServerConnectionNew = (baseSocket, certificate) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_dtls_server_connection_new", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: baseSocket?.id ?? baseSocket,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: baseSocket.id,
         },
         {
-            type: { type: "gobject", borrowed: true },
-            value: certificate?.id ?? certificate,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: certificate?.id,
             optional: true,
         },
         {
@@ -1819,15 +2557,19 @@ export const dtlsServerConnectionNew = (baseSocket, certificate) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr, DtlsServerConnection);
 };
@@ -1837,15 +2579,25 @@ export const dtlsServerConnectionNew = (baseSocket, certificate) => {
  *
  * Using this function is equivalent to calling g_build_filenamev(),
  * followed by g_file_new_for_path() on the result.
- * @param args - %NULL-terminated
  */
 export const fileNewBuildFilenamev = (args) => {
     const ptr = call("libgio-2.0.so.0", "g_file_new_build_filenamev", [
         {
-            type: { type: "array", itemType: { type: "string", borrowed: true } },
+            type: {
+                type: "array",
+                itemType: {
+                    type: "string",
+                    ownership: "none",
+                },
+                listType: "array",
+                ownership: "none",
+            },
             value: args,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     return getNativeObject(ptr, File);
 };
 /**
@@ -1863,15 +2615,20 @@ export const fileNewBuildFilenamev = (args) => {
  * g_application_command_line_create_file_for_arg() may be more useful
  * for you there.  It is also always possible to use this function with
  * #GOptionContext arguments of type %G_OPTION_ARG_FILENAME.
- * @param arg - a command line string
  */
 export const fileNewForCommandlineArg = (arg) => {
     const ptr = call("libgio-2.0.so.0", "g_file_new_for_commandline_arg", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: arg,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     return getNativeObject(ptr, File);
 };
 /**
@@ -1886,35 +2643,47 @@ export const fileNewForCommandlineArg = (arg) => {
  * other than the invocation of the current process.
  *
  * See also g_application_command_line_create_file_for_arg().
- * @param arg - a command line string
- * @param cwd - the current working directory of the commandline
  */
 export const fileNewForCommandlineArgAndCwd = (arg, cwd) => {
     const ptr = call("libgio-2.0.so.0", "g_file_new_for_commandline_arg_and_cwd", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: arg,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: cwd,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     return getNativeObject(ptr, File);
 };
 /**
  * Constructs a #GFile for a given path. This operation never
  * fails, but the returned object might not support any I/O
  * operation if `path` is malformed.
- * @param path - a string containing a relative or absolute path.
  */
 export const fileNewForPath = (path) => {
     const ptr = call("libgio-2.0.so.0", "g_file_new_for_path", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: path,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     return getNativeObject(ptr, File);
 };
 /**
@@ -1922,15 +2691,20 @@ export const fileNewForPath = (path) => {
  * fails, but the returned object might not support any I/O
  * operation if `uri` is malformed or if the uri type is
  * not supported.
- * @param uri - a UTF-8 string containing a URI
  */
 export const fileNewForUri = (uri) => {
     const ptr = call("libgio-2.0.so.0", "g_file_new_for_uri", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: uri,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     return getNativeObject(ptr, File);
 };
 /**
@@ -1944,19 +2718,26 @@ export const fileNewForUri = (uri) => {
  *
  * Unlike the other #GFile constructors, this will return %NULL if
  * a temporary file could not be created.
- * @param tmpl - Template for the file
- * @param iostream - on return, a #GFileIOStream for the created file
  */
 export const fileNewTmp = (iostream, tmpl) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_file_new_tmp", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: tmpl,
             optional: true,
         },
         {
-            type: { type: "ref", innerType: { type: "gobject" } },
+            type: {
+                type: "ref",
+                innerType: {
+                    type: "gobject",
+                    ownership: "full",
+                },
+            },
             value: iostream,
         },
         {
@@ -1964,62 +2745,196 @@ export const fileNewTmp = (iostream, tmpl) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
-    iostream.value = getNativeObject(iostream.value);
+    if (iostream)
+        iostream.value = getNativeObject(iostream.value);
     return getNativeObject(ptr, File);
 };
+/**
+ * Asynchronously opens a file in the preferred directory for temporary files
+ *  (as returned by g_get_tmp_dir()) as g_file_new_tmp().
+ *
+ * `tmpl` should be a string in the GLib file name encoding
+ * containing a sequence of six 'X' characters, and containing no
+ * directory components. If it is %NULL, a default template is used.
+ */
+export const fileNewTmpAsync = (ioPriority, tmpl, cancellable, callback) => {
+    const wrappedCallback = callback
+        ? (...args) => callback(getNativeObject(args[0]), getNativeObject(args[1], AsyncResult))
+        : null;
+    call("libgio-2.0.so.0", "g_file_new_tmp_async", [
+        {
+            type: {
+                type: "string",
+                ownership: "none",
+            },
+            value: tmpl,
+            optional: true,
+        },
+        {
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
+            value: ioPriority,
+        },
+        {
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: cancellable?.id,
+            optional: true,
+        },
+        {
+            type: {
+                type: "callback",
+                trampoline: "asyncReady",
+                argTypes: [
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                ],
+            },
+            value: wrappedCallback,
+            optional: true,
+        },
+    ], {
+        type: "undefined",
+    });
+};
+/**
+ * Asynchronously creates a directory in the preferred directory for
+ * temporary files (as returned by g_get_tmp_dir()) as g_dir_make_tmp().
+ *
+ * `tmpl` should be a string in the GLib file name encoding
+ * containing a sequence of six 'X' characters, and containing no
+ * directory components. If it is %NULL, a default template is used.
+ */
+export const fileNewTmpDirAsync = (ioPriority, tmpl, cancellable, callback) => {
+    const wrappedCallback = callback
+        ? (...args) => callback(getNativeObject(args[0]), getNativeObject(args[1], AsyncResult))
+        : null;
+    call("libgio-2.0.so.0", "g_file_new_tmp_dir_async", [
+        {
+            type: {
+                type: "string",
+                ownership: "none",
+            },
+            value: tmpl,
+            optional: true,
+        },
+        {
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
+            value: ioPriority,
+        },
+        {
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: cancellable?.id,
+            optional: true,
+        },
+        {
+            type: {
+                type: "callback",
+                trampoline: "asyncReady",
+                argTypes: [
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                ],
+            },
+            value: wrappedCallback,
+            optional: true,
+        },
+    ], {
+        type: "undefined",
+    });
+};
 /**
  * Finishes a temporary directory creation started by
  * g_file_new_tmp_dir_async().
- * @param result - a #GAsyncResult
  */
 export const fileNewTmpDirFinish = (result) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_file_new_tmp_dir_finish", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: result?.id ?? result,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: result.id,
         },
         {
             type: {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr, File);
 };
-/**
- * Finishes a temporary file creation started by g_file_new_tmp_async().
- * @param result - a #GAsyncResult
- * @param iostream - on return, a #GFileIOStream for the created file
- */
+/** Finishes a temporary file creation started by g_file_new_tmp_async(). */
 export const fileNewTmpFinish = (result, iostream) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_file_new_tmp_finish", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: result?.id ?? result,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: result.id,
         },
         {
-            type: { type: "ref", innerType: { type: "gobject" } },
+            type: {
+                type: "ref",
+                innerType: {
+                    type: "gobject",
+                    ownership: "full",
+                },
+            },
             value: iostream,
         },
         {
@@ -2027,17 +2942,22 @@ export const fileNewTmpFinish = (result, iostream) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
-    iostream.value = getNativeObject(iostream.value);
+    if (iostream)
+        iostream.value = getNativeObject(iostream.value);
     return getNativeObject(ptr, File);
 };
 /**
@@ -2045,28 +2965,36 @@ export const fileNewTmpFinish = (result, iostream) => {
  * given by g_file_get_parse_name()). This operation never fails,
  * but the returned object might not support any I/O operation if
  * the `parse_name` cannot be parsed.
- * @param parseName - a file name or path to be parsed
  */
 export const fileParseName = (parseName) => {
     const ptr = call("libgio-2.0.so.0", "g_file_parse_name", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: parseName,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     return getNativeObject(ptr, File);
 };
-/**
- * Deserializes a #GIcon previously serialized using g_icon_serialize().
- * @param value - a #GVariant created with g_icon_serialize()
- */
+/** Deserializes a #GIcon previously serialized using g_icon_serialize(). */
 export const iconDeserialize = (value) => {
     const ptr = call("libgio-2.0.so.0", "g_icon_deserialize", [
         {
-            type: { type: "gvariant" },
+            type: {
+                type: "gvariant",
+                ownership: "none",
+            },
             value: value,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (ptr === null)
         return null;
     return getNativeObject(ptr, Icon);
@@ -2078,13 +3006,15 @@ export const iconDeserialize = (value) => {
  * If your application or library provides one or more #GIcon
  * implementations you need to ensure that each #GType is registered
  * with the type system prior to calling g_icon_new_for_string().
- * @param str - A string obtained via g_icon_to_string().
  */
 export const iconNewForString = (str) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_icon_new_for_string", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: str,
         },
         {
@@ -2092,15 +3022,19 @@ export const iconNewForString = (str) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr, Icon);
 };
@@ -2108,32 +3042,45 @@ export const iconNewForString = (str) => {
  * Helper function for constructing #GInitable object. This is
  * similar to g_object_newv() but also initializes the object
  * and returns %NULL, setting an error on failure.
- * @param objectType - a #GType supporting #GInitable.
- * @param nParameters - the number of parameters in `parameters`
- * @param parameters - the parameters to use to construct the object
- * @param cancellable - optional #GCancellable object, %NULL to ignore.
  */
 export const initableNewv = (objectType, nParameters, parameters, cancellable) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_initable_newv", [
         {
-            type: { type: "int", size: 64, unsigned: true },
+            type: {
+                type: "int",
+                size: 64,
+                unsigned: true,
+            },
             value: objectType,
         },
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: nParameters,
         },
         {
             type: {
                 type: "array",
-                itemType: { type: "int", size: 64, unsigned: true },
+                itemType: {
+                    type: "struct",
+                    ownership: "none",
+                    innerType: "Parameter",
+                },
+                listType: "array",
+                ownership: "none",
             },
             value: parameters,
         },
         {
-            type: { type: "gobject", borrowed: true },
-            value: cancellable?.id ?? cancellable,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: cancellable?.id,
             optional: true,
         },
         {
@@ -2141,15 +3088,19 @@ export const initableNewv = (objectType, nParameters, parameters, cancellable) =
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr);
 };
@@ -2165,38 +3116,48 @@ export const initableNewv = (objectType, nParameters, parameters, cancellable) =
  * and use the saved value instead of `errno`:
  *
  * |[<!-- language="C" -->
- * int saved_errno;
+ *   int saved_errno;
  *
- * ret = read (blah);
- * saved_errno = errno;
+ *   ret = read (blah);
+ *   saved_errno = errno;
  *
- * g_io_error_from_errno (saved_errno);
+ *   g_io_error_from_errno (saved_errno);
  * ]|
- * @param errNo - Error number as defined in errno.h.
  */
 export const ioErrorFromErrno = (errNo) => {
     return call("libgio-2.0.so.0", "g_io_error_from_errno", [
         {
-            type: { type: "int", size: 32, unsigned: false },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
             value: errNo,
         },
-    ], { type: "int", size: 32, unsigned: false });
+    ], {
+        type: "int",
+        size: 32,
+        unsigned: false,
+    });
 };
-/**
- * Converts #GFileError error codes into GIO error codes.
- * @param fileError - a #GFileError.
- */
+/** Converts #GFileError error codes into GIO error codes. */
 export const ioErrorFromFileError = (fileError) => {
     return call("libgio-2.0.so.0", "g_io_error_from_file_error", [
         {
-            type: { type: "int", size: 32, unsigned: false },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
             value: fileError,
         },
-    ], { type: "int", size: 32, unsigned: false });
+    ], {
+        type: "int",
+        size: 32,
+        unsigned: false,
+    });
 };
-/**
- * Gets the GIO Error Quark.
- */
+/** Gets the GIO Error Quark. */
 export const ioErrorQuark = () => {
     return call("libgio-2.0.so.0", "g_io_error_quark", [], {
         type: "int",
@@ -2210,54 +3171,76 @@ export const ioErrorQuark = () => {
  *
  * If `type` has already been registered as an extension for this
  * extension point, the existing #GIOExtension object is returned.
- * @param extensionPointName - the name of the extension point
- * @param type - the #GType to register as extension
- * @param extensionName - the name for the extension
- * @param priority - the priority for the extension
  */
 export const ioExtensionPointImplement = (extensionPointName, type, extensionName, priority) => {
     return call("libgio-2.0.so.0", "g_io_extension_point_implement", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: extensionPointName,
         },
         {
-            type: { type: "int", size: 64, unsigned: true },
+            type: {
+                type: "int",
+                size: 64,
+                unsigned: true,
+            },
             value: type,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: extensionName,
         },
         {
-            type: { type: "int", size: 32, unsigned: false },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
             value: priority,
         },
-    ], { type: "int", size: 64, unsigned: true });
+    ], {
+        type: "struct",
+        ownership: "none",
+        innerType: "IOExtension",
+    });
 };
-/**
- * Looks up an existing extension point.
- * @param name - the name of the extension point
- */
+/** Looks up an existing extension point. */
 export const ioExtensionPointLookup = (name) => {
     return call("libgio-2.0.so.0", "g_io_extension_point_lookup", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: name,
         },
-    ], { type: "int", size: 64, unsigned: true });
+    ], {
+        type: "struct",
+        ownership: "none",
+        innerType: "IOExtensionPoint",
+    });
 };
-/**
- * Registers an extension point.
- * @param name - The name of the extension point
- */
+/** Registers an extension point. */
 export const ioExtensionPointRegister = (name) => {
     return call("libgio-2.0.so.0", "g_io_extension_point_register", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: name,
         },
-    ], { type: "int", size: 64, unsigned: true });
+    ], {
+        type: "struct",
+        ownership: "none",
+        innerType: "IOExtensionPoint",
+    });
 };
 /**
  * Loads all the modules in the specified directory.
@@ -2265,20 +3248,26 @@ export const ioExtensionPointRegister = (name) => {
  * If don't require all modules to be initialized (and thus registering
  * all gtypes) then you can use g_io_modules_scan_all_in_directory()
  * which allows delayed/lazy loading of modules.
- * @param dirname - pathname for a directory containing modules
  */
 export const ioModulesLoadAllInDirectory = (dirname) => {
-    return call("libgio-2.0.so.0", "g_io_modules_load_all_in_directory", [
+    const arr = call("libgio-2.0.so.0", "g_io_modules_load_all_in_directory", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: dirname,
         },
     ], {
         type: "array",
-        itemType: { type: "gobject", borrowed: true },
+        itemType: {
+            type: "gobject",
+            ownership: "full",
+        },
         listType: "glist",
-        borrowed: true,
+        ownership: "full",
     });
+    return arr.map((item) => getNativeObject(item));
 };
 /**
  * Loads all the modules in the specified directory.
@@ -2286,25 +3275,34 @@ export const ioModulesLoadAllInDirectory = (dirname) => {
  * If don't require all modules to be initialized (and thus registering
  * all gtypes) then you can use g_io_modules_scan_all_in_directory()
  * which allows delayed/lazy loading of modules.
- * @param dirname - pathname for a directory containing modules
- * @param scope - a scope to use when scanning the modules.
  */
 export const ioModulesLoadAllInDirectoryWithScope = (dirname, scope) => {
-    return call("libgio-2.0.so.0", "g_io_modules_load_all_in_directory_with_scope", [
+    const arr = call("libgio-2.0.so.0", "g_io_modules_load_all_in_directory_with_scope", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: dirname,
         },
         {
-            type: { type: "int", size: 64, unsigned: true },
-            value: scope,
+            type: {
+                type: "struct",
+                ownership: "none",
+                innerType: "IOModuleScope",
+            },
+            value: scope.id,
         },
     ], {
         type: "array",
-        itemType: { type: "gobject", borrowed: true },
+        itemType: {
+            type: "gobject",
+            ownership: "full",
+        },
         listType: "glist",
-        borrowed: true,
+        ownership: "full",
     });
+    return arr.map((item) => getNativeObject(item));
 };
 /**
  * Scans all the modules in the specified directory, ensuring that
@@ -2318,15 +3316,19 @@ export const ioModulesLoadAllInDirectoryWithScope = (dirname, scope) => {
  *
  * If you need to guarantee that all types are loaded in all the modules,
  * use g_io_modules_load_all_in_directory().
- * @param dirname - pathname for a directory containing modules
  */
 export const ioModulesScanAllInDirectory = (dirname) => {
     call("libgio-2.0.so.0", "g_io_modules_scan_all_in_directory", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: dirname,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
 };
 /**
  * Scans all the modules in the specified directory, ensuring that
@@ -2340,20 +3342,27 @@ export const ioModulesScanAllInDirectory = (dirname) => {
  *
  * If you need to guarantee that all types are loaded in all the modules,
  * use g_io_modules_load_all_in_directory().
- * @param dirname - pathname for a directory containing modules
- * @param scope - a scope to use when scanning the modules
  */
 export const ioModulesScanAllInDirectoryWithScope = (dirname, scope) => {
     call("libgio-2.0.so.0", "g_io_modules_scan_all_in_directory_with_scope", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: dirname,
         },
         {
-            type: { type: "int", size: 64, unsigned: true },
-            value: scope,
+            type: {
+                type: "struct",
+                ownership: "none",
+                innerType: "IOModuleScope",
+            },
+            value: scope.id,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
 };
 /**
  * Cancels all cancellable I/O jobs.
@@ -2416,35 +3425,42 @@ export const ioSchedulerCancelAllJobs = () => {
  * the directory specified by the `GKeyfileSettingsBackend:defaults-dir`
  * property, and a list of locked keys from a text file with the name `locks` in
  * the same location.
- * @param filename - the filename of the keyfile
- * @param rootPath - the path under which all settings keys appear
- * @param rootGroup - the group name corresponding to `root_path`, or
  */
 export const keyfileSettingsBackendNew = (filename, rootPath, rootGroup) => {
     const ptr = call("libgio-2.0.so.0", "g_keyfile_settings_backend_new", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: filename,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: rootPath,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: rootGroup,
             optional: true,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     return getNativeObject(ptr);
 };
-/**
- * Gets a reference to the default #GMemoryMonitor for the system.
- */
+/** Gets a reference to the default #GMemoryMonitor for the system. */
 export const memoryMonitorDupDefault = () => {
     const ptr = call("libgio-2.0.so.0", "g_memory_monitor_dup_default", [], {
         type: "gobject",
-        borrowed: true,
+        ownership: "full",
     });
     return getNativeObject(ptr, MemoryMonitor);
 };
@@ -2458,17 +3474,15 @@ export const memoryMonitorDupDefault = () => {
 export const memorySettingsBackendNew = () => {
     const ptr = call("libgio-2.0.so.0", "g_memory_settings_backend_new", [], {
         type: "gobject",
-        borrowed: true,
+        ownership: "full",
     });
     return getNativeObject(ptr);
 };
-/**
- * Gets the default #GNetworkMonitor for the system.
- */
+/** Gets the default #GNetworkMonitor for the system. */
 export const networkMonitorGetDefault = () => {
     const ptr = call("libgio-2.0.so.0", "g_network_monitor_get_default", [], {
         type: "gobject",
-        borrowed: true,
+        ownership: "none",
     });
     return getNativeObject(ptr, NetworkMonitor);
 };
@@ -2479,7 +3493,9 @@ export const networkMonitorGetDefault = () => {
  * functions (without calling any GLib networking functions first).
  */
 export const networkingInit = () => {
-    call("libgio-2.0.so.0", "g_networking_init", [], { type: "undefined" });
+    call("libgio-2.0.so.0", "g_networking_init", [], {
+        type: "undefined",
+    });
 };
 /**
  * Creates a readonly #GSettingsBackend.
@@ -2490,7 +3506,7 @@ export const networkingInit = () => {
 export const nullSettingsBackendNew = () => {
     const ptr = call("libgio-2.0.so.0", "g_null_settings_backend_new", [], {
         type: "gobject",
-        borrowed: true,
+        ownership: "full",
     });
     return getNativeObject(ptr);
 };
@@ -2500,17 +3516,19 @@ export const nullSettingsBackendNew = () => {
  * type #GPollableSourceFunc. The new source does not actually do
  * anything on its own; use g_source_add_child_source() to add other
  * sources to it to cause it to trigger.
- * @param pollableStream - the stream associated with the new source
  */
 export const pollableSourceNew = (pollableStream) => {
     const ptr = call("libgio-2.0.so.0", "g_pollable_source_new", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: pollableStream?.id ?? pollableStream,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: pollableStream.id,
         },
     ], {
         type: "boxed",
-        borrowed: true,
+        ownership: "full",
         innerType: "GSource",
         lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
         getTypeFn: "g_source_get_type",
@@ -2522,35 +3540,38 @@ export const pollableSourceNew = (pollableStream) => {
  * implementations. Creates a new #GSource, as with
  * g_pollable_source_new(), but also attaching `child_source` (with a
  * dummy callback), and `cancellable`, if they are non-%NULL.
- * @param pollableStream - the stream associated with the
- * @param childSource - optional child source to attach
- * @param cancellable - optional #GCancellable to attach
  */
 export const pollableSourceNewFull = (pollableStream, childSource, cancellable) => {
     const ptr = call("libgio-2.0.so.0", "g_pollable_source_new_full", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: pollableStream?.id ?? pollableStream,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: pollableStream.id,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GSource",
                 lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                 getTypeFn: "g_source_get_type",
             },
-            value: childSource?.id ?? childSource,
+            value: childSource?.id,
             optional: true,
         },
         {
-            type: { type: "gobject", borrowed: true },
-            value: cancellable?.id ?? cancellable,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: cancellable?.id,
             optional: true,
         },
     ], {
         type: "boxed",
-        borrowed: true,
+        ownership: "full",
         innerType: "GSource",
         lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
         getTypeFn: "g_source_get_type",
@@ -2567,37 +3588,50 @@ export const pollableSourceNewFull = (pollableStream, childSource, cancellable)
  * #GPollableInputStream for which g_pollable_input_stream_can_poll()
  * returns %TRUE, or else the behavior is undefined. If `blocking` is
  * %TRUE, then `stream` does not need to be a #GPollableInputStream.
- * @param stream - a #GInputStream
- * @param buffer - a buffer to
- * @param count - the number of bytes to read
- * @param blocking - whether to do blocking I/O
- * @param cancellable - optional #GCancellable object, %NULL to ignore.
  */
 export const pollableStreamRead = (stream, buffer, count, blocking, cancellable) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_pollable_stream_read", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: stream?.id ?? stream,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: stream.id,
         },
         {
             type: {
                 type: "array",
-                itemType: { type: "int", size: 8, unsigned: true },
+                itemType: {
+                    type: "int",
+                    size: 8,
+                    unsigned: true,
+                },
+                listType: "array",
+                ownership: "none",
             },
             value: buffer,
         },
         {
-            type: { type: "int", size: 64, unsigned: true },
+            type: {
+                type: "int",
+                size: 64,
+                unsigned: true,
+            },
             value: count,
         },
         {
-            type: { type: "boolean" },
+            type: {
+                type: "boolean",
+            },
             value: blocking,
         },
         {
-            type: { type: "gobject", borrowed: true },
-            value: cancellable?.id ?? cancellable,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: cancellable?.id,
             optional: true,
         },
         {
@@ -2605,15 +3639,20 @@ export const pollableStreamRead = (stream, buffer, count, blocking, cancellable)
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "int", size: 64, unsigned: false });
+    ], {
+        type: "int",
+        size: 64,
+        unsigned: false,
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return result;
 };
@@ -2628,37 +3667,50 @@ export const pollableStreamRead = (stream, buffer, count, blocking, cancellable)
  * g_pollable_output_stream_can_poll() returns %TRUE or else the
  * behavior is undefined. If `blocking` is %TRUE, then `stream` does not
  * need to be a #GPollableOutputStream.
- * @param stream - a #GOutputStream.
- * @param buffer - the buffer
- * @param count - the number of bytes to write
- * @param blocking - whether to do blocking I/O
- * @param cancellable - optional #GCancellable object, %NULL to ignore.
  */
 export const pollableStreamWrite = (stream, buffer, count, blocking, cancellable) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_pollable_stream_write", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: stream?.id ?? stream,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: stream.id,
         },
         {
             type: {
                 type: "array",
-                itemType: { type: "int", size: 8, unsigned: true },
+                itemType: {
+                    type: "int",
+                    size: 8,
+                    unsigned: true,
+                },
+                listType: "array",
+                ownership: "none",
             },
             value: buffer,
         },
         {
-            type: { type: "int", size: 64, unsigned: true },
+            type: {
+                type: "int",
+                size: 64,
+                unsigned: true,
+            },
             value: count,
         },
         {
-            type: { type: "boolean" },
+            type: {
+                type: "boolean",
+            },
             value: blocking,
         },
         {
-            type: { type: "gobject", borrowed: true },
-            value: cancellable?.id ?? cancellable,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: cancellable?.id,
             optional: true,
         },
         {
@@ -2666,15 +3718,20 @@ export const pollableStreamWrite = (stream, buffer, count, blocking, cancellable
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "int", size: 64, unsigned: false });
+    ], {
+        type: "int",
+        size: 64,
+        unsigned: false,
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return result;
 };
@@ -2697,45 +3754,61 @@ export const pollableStreamWrite = (stream, buffer, count, blocking, cancellable
  * g_pollable_output_stream_can_poll() returns %TRUE or else the
  * behavior is undefined. If `blocking` is %TRUE, then `stream` does not
  * need to be a #GPollableOutputStream.
- * @param stream - a #GOutputStream.
- * @param buffer - the buffer
- * @param count - the number of bytes to write
- * @param blocking - whether to do blocking I/O
- * @param bytesWritten - location to store the number of bytes that was
- * @param cancellable - optional #GCancellable object, %NULL to ignore.
  */
 export const pollableStreamWriteAll = (stream, buffer, count, blocking, bytesWritten, cancellable) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_pollable_stream_write_all", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: stream?.id ?? stream,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: stream.id,
         },
         {
             type: {
                 type: "array",
-                itemType: { type: "int", size: 8, unsigned: true },
+                itemType: {
+                    type: "int",
+                    size: 8,
+                    unsigned: true,
+                },
+                listType: "array",
+                ownership: "none",
             },
             value: buffer,
         },
         {
-            type: { type: "int", size: 64, unsigned: true },
+            type: {
+                type: "int",
+                size: 64,
+                unsigned: true,
+            },
             value: count,
         },
         {
-            type: { type: "boolean" },
+            type: {
+                type: "boolean",
+            },
             value: blocking,
         },
         {
             type: {
                 type: "ref",
-                innerType: { type: "int", size: 64, unsigned: true },
+                innerType: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
             },
             value: bytesWritten,
         },
         {
-            type: { type: "gobject", borrowed: true },
-            value: cancellable?.id ?? cancellable,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: cancellable?.id,
             optional: true,
         },
         {
@@ -2743,54 +3816,59 @@ export const pollableStreamWriteAll = (stream, buffer, count, blocking, bytesWri
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return result;
 };
-/**
- * Gets a reference to the default #GPowerProfileMonitor for the system.
- */
+/** Gets a reference to the default #GPowerProfileMonitor for the system. */
 export const powerProfileMonitorDupDefault = () => {
-    const ptr = call("libgio-2.0.so.0", "g_power_profile_monitor_dup_default", [], { type: "gobject", borrowed: true });
+    const ptr = call("libgio-2.0.so.0", "g_power_profile_monitor_dup_default", [], {
+        type: "gobject",
+        ownership: "full",
+    });
     return getNativeObject(ptr, PowerProfileMonitor);
 };
 /**
  * Find the `gio-proxy` extension point for a proxy implementation that supports
  * the specified protocol.
- * @param protocol - the proxy protocol name (e.g. http, socks, etc)
  */
 export const proxyGetDefaultForProtocol = (protocol) => {
     const ptr = call("libgio-2.0.so.0", "g_proxy_get_default_for_protocol", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: protocol,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (ptr === null)
         return null;
     return getNativeObject(ptr, Proxy);
 };
-/**
- * Gets the default #GProxyResolver for the system.
- */
+/** Gets the default #GProxyResolver for the system. */
 export const proxyResolverGetDefault = () => {
     const ptr = call("libgio-2.0.so.0", "g_proxy_resolver_get_default", [], {
         type: "gobject",
-        borrowed: true,
+        ownership: "none",
     });
     return getNativeObject(ptr, ProxyResolver);
 };
-/**
- * Gets the #GResolver Error Quark.
- */
+/** Gets the #GResolver Error Quark. */
 export const resolverErrorQuark = () => {
     return call("libgio-2.0.so.0", "g_resolver_error_quark", [], {
         type: "int",
@@ -2798,9 +3876,7 @@ export const resolverErrorQuark = () => {
         unsigned: true,
     });
 };
-/**
- * Gets the {@link Gio.Resource} Error Quark.
- */
+/** Gets the {@link Gio.Resource} Error Quark. */
 export const resourceErrorQuark = () => {
     return call("libgio-2.0.so.0", "g_resource_error_quark", [], {
         type: "int",
@@ -2819,13 +3895,15 @@ export const resourceErrorQuark = () => {
  * %G_RESOURCE_ERROR_INTERNAL will be returned. If `filename` doesn’t exist, or
  * there is an error in reading it, an error from {@link GLib.MappedFile.new}
  * will be returned.
- * @param filename - the path of a filename to load, in the GLib filename encoding
  */
 export const resourceLoad = (filename) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_resource_load", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: filename,
         },
         {
@@ -2833,21 +3911,22 @@ export const resourceLoad = (filename) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
     ], {
         type: "boxed",
-        borrowed: true,
+        ownership: "full",
         innerType: "GResource",
         lib: "libgio-2.0.so.0",
         getTypeFn: "g_resource_get_type",
     });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr, Resource);
 };
@@ -2859,18 +3938,23 @@ export const resourceLoad = (filename) => {
  * be released with {@link GLib.strfreev}.
  *
  * `lookup_flags` controls the behaviour of the lookup.
- * @param path - A path name inside the resource
- * @param lookupFlags - A {@link Gio.ResourceLookupFlags}
  */
 export const resourcesEnumerateChildren = (path, lookupFlags) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_resources_enumerate_children", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: path,
         },
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: lookupFlags,
         },
         {
@@ -2878,15 +3962,24 @@ export const resourcesEnumerateChildren = (path, lookupFlags) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "array", itemType: { type: "string" } });
+    ], {
+        type: "array",
+        itemType: {
+            type: "string",
+            ownership: "full",
+        },
+        listType: "array",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return result;
 };
@@ -2895,26 +3988,33 @@ export const resourcesEnumerateChildren = (path, lookupFlags) => {
  * globally registered resources and if found returns information about it.
  *
  * `lookup_flags` controls the behaviour of the lookup.
- * @param path - A path name inside the resource
- * @param lookupFlags - A {@link Gio.ResourceLookupFlags}
- * @param size - a location to place the length of the contents of the file,
- * @param flags - a location to place the {@link Gio.ResourceFlags} about the file,
  */
 export const resourcesGetInfo = (path, lookupFlags, size, flags) => {
     const error = { value: null };
     const result = call("libgio-2.0.so.0", "g_resources_get_info", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: path,
         },
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: lookupFlags,
         },
         {
             type: {
                 type: "ref",
-                innerType: { type: "int", size: 64, unsigned: true },
+                innerType: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
             },
             value: size,
             optional: true,
@@ -2922,7 +4022,11 @@ export const resourcesGetInfo = (path, lookupFlags, size, flags) => {
         {
             type: {
                 type: "ref",
-                innerType: { type: "int", size: 32, unsigned: true },
+                innerType: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
             },
             value: flags,
             optional: true,
@@ -2932,30 +4036,37 @@ export const resourcesGetInfo = (path, lookupFlags, size, flags) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return result;
 };
 /**
  * Returns whether the specified `path` in the set of
  * globally registered resources has children.
- * @param path - A pathname
  */
 export const resourcesHasChildren = (path) => {
     return call("libgio-2.0.so.0", "g_resources_has_children", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: path,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
 /**
  * Looks for a file at the specified `path` in the set of
@@ -2972,18 +4083,23 @@ export const resourcesHasChildren = (path) => {
  * the heap and automatically uncompress the data.
  *
  * `lookup_flags` controls the behaviour of the lookup.
- * @param path - A path name inside the resource
- * @param lookupFlags - A {@link Gio.ResourceLookupFlags}
  */
 export const resourcesLookupData = (path, lookupFlags) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_resources_lookup_data", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: path,
         },
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: lookupFlags,
         },
         {
@@ -2991,21 +4107,22 @@ export const resourcesLookupData = (path, lookupFlags) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
     ], {
         type: "boxed",
-        borrowed: true,
+        ownership: "full",
         innerType: "GBytes",
         lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
         getTypeFn: "g_bytes_get_type",
     });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr, GLib.Bytes);
 };
@@ -3015,18 +4132,23 @@ export const resourcesLookupData = (path, lookupFlags) => {
  * that lets you read the data.
  *
  * `lookup_flags` controls the behaviour of the lookup.
- * @param path - A path name inside the resource
- * @param lookupFlags - A {@link Gio.ResourceLookupFlags}
  */
 export const resourcesOpenStream = (path, lookupFlags) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_resources_open_stream", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: path,
         },
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: lookupFlags,
         },
         {
@@ -3034,15 +4156,19 @@ export const resourcesOpenStream = (path, lookupFlags) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr);
 };
@@ -3052,39 +4178,39 @@ export const resourcesOpenStream = (path, lookupFlags) => {
  * Once a resource is registered the files in it can be accessed
  * with the global resource lookup functions like
  * {@link Gio.resources_lookup_data}.
- * @param resource - A {@link Gio.Resource}
  */
 export const resourcesRegister = (resource) => {
     call("libgio-2.0.so.0", "g_resources_register", [
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GResource",
                 lib: "libgio-2.0.so.0",
                 getTypeFn: "g_resource_get_type",
             },
-            value: resource?.id ?? resource,
+            value: resource.id,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
 };
-/**
- * Unregisters the resource from the process-global set of resources.
- * @param resource - A {@link Gio.Resource}
- */
+/** Unregisters the resource from the process-global set of resources. */
 export const resourcesUnregister = (resource) => {
     call("libgio-2.0.so.0", "g_resources_unregister", [
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GResource",
                 lib: "libgio-2.0.so.0",
                 getTypeFn: "g_resource_get_type",
             },
-            value: resource?.id ?? resource,
+            value: resource.id,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
 };
 /**
  * Gets the default system schema source.
@@ -3104,7 +4230,7 @@ export const resourcesUnregister = (resource) => {
 export const settingsSchemaSourceGetDefault = () => {
     const ptr = call("libgio-2.0.so.0", "g_settings_schema_source_get_default", [], {
         type: "boxed",
-        borrowed: true,
+        ownership: "none",
         innerType: "GSettingsSchemaSource",
         lib: "libgio-2.0.so.0",
         getTypeFn: "g_settings_schema_source_get_type",
@@ -3114,18 +4240,64 @@ export const settingsSchemaSourceGetDefault = () => {
     return getNativeObject(ptr, SettingsSchemaSource);
 };
 /**
- * Gets the default #GTlsBackend for the system.
+ * Reports an error in an idle function. Similar to
+ * g_simple_async_report_error_in_idle(), but takes a #GError rather
+ * than building a new one.
  */
+export const simpleAsyncReportGerrorInIdle = (error, object, callback) => {
+    const wrappedCallback = callback
+        ? (...args) => callback(getNativeObject(args[0]), getNativeObject(args[1], AsyncResult))
+        : null;
+    call("libgio-2.0.so.0", "g_simple_async_report_gerror_in_idle", [
+        {
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: object?.id,
+            optional: true,
+        },
+        {
+            type: {
+                type: "callback",
+                trampoline: "asyncReady",
+                argTypes: [
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                ],
+            },
+            value: wrappedCallback,
+            optional: true,
+        },
+        {
+            type: {
+                type: "boxed",
+                ownership: "none",
+                innerType: "GError",
+                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                getTypeFn: "g_error_get_type",
+            },
+            value: error.id,
+        },
+    ], {
+        type: "undefined",
+    });
+};
+/** Gets the default #GTlsBackend for the system. */
 export const tlsBackendGetDefault = () => {
     const ptr = call("libgio-2.0.so.0", "g_tls_backend_get_default", [], {
         type: "gobject",
-        borrowed: true,
+        ownership: "none",
     });
     return getNativeObject(ptr, TlsBackend);
 };
-/**
- * Gets the TLS channel binding error quark.
- */
+/** Gets the TLS channel binding error quark. */
 export const tlsChannelBindingErrorQuark = () => {
     return call("libgio-2.0.so.0", "g_tls_channel_binding_error_quark", [], {
         type: "int",
@@ -3141,19 +4313,23 @@ export const tlsChannelBindingErrorQuark = () => {
  * See the documentation for #GTlsConnection:base-io-stream for restrictions
  * on when application code can run operations on the `base_io_stream` after
  * this function has returned.
- * @param baseIoStream - the #GIOStream to wrap
- * @param serverIdentity - the expected identity of the server
  */
 export const tlsClientConnectionNew = (baseIoStream, serverIdentity) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_tls_client_connection_new", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: baseIoStream?.id ?? baseIoStream,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: baseIoStream.id,
         },
         {
-            type: { type: "gobject", borrowed: true },
-            value: serverIdentity?.id ?? serverIdentity,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: serverIdentity?.id,
             optional: true,
         },
         {
@@ -3161,21 +4337,23 @@ export const tlsClientConnectionNew = (baseIoStream, serverIdentity) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr, TlsClientConnection);
 };
-/**
- * Gets the TLS error quark.
- */
+/** Gets the TLS error quark. */
 export const tlsErrorQuark = () => {
     return call("libgio-2.0.so.0", "g_tls_error_quark", [], {
         type: "int",
@@ -3188,13 +4366,15 @@ export const tlsErrorQuark = () => {
  * in `anchors` to verify certificate chains.
  *
  * The certificates in `anchors` must be PEM encoded.
- * @param anchors - filename of anchor certificate authorities.
  */
 export const tlsFileDatabaseNew = (anchors) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_tls_file_database_new", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: anchors,
         },
         {
@@ -3202,15 +4382,19 @@ export const tlsFileDatabaseNew = (anchors) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr, TlsFileDatabase);
 };
@@ -3221,19 +4405,23 @@ export const tlsFileDatabaseNew = (anchors) => {
  * See the documentation for #GTlsConnection:base-io-stream for restrictions
  * on when application code can run operations on the `base_io_stream` after
  * this function has returned.
- * @param baseIoStream - the #GIOStream to wrap
- * @param certificate - the default server certificate, or %NULL
  */
 export const tlsServerConnectionNew = (baseIoStream, certificate) => {
     const error = { value: null };
     const ptr = call("libgio-2.0.so.0", "g_tls_server_connection_new", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: baseIoStream?.id ?? baseIoStream,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: baseIoStream.id,
         },
         {
-            type: { type: "gobject", borrowed: true },
-            value: certificate?.id ?? certificate,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: certificate?.id,
             optional: true,
         },
         {
@@ -3241,15 +4429,19 @@ export const tlsServerConnectionNew = (baseIoStream, certificate) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "gobject", borrowed: true });
+    ], {
+        type: "gobject",
+        ownership: "full",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return getNativeObject(ptr, TlsServerConnection);
 };