@gtkx/ffi 0.10.5 → 0.11.1

package/dist/generated/gio/socket.js

@@ -77,12 +77,6 @@ import * as GObject from "../gobject/index.js";
  *   }
  * ```
  */
-const SIGNAL_META = {
-    notify: {
-        params: [{ type: "gparam", borrowed: true }],
-        returnType: { type: "undefined" },
-    },
-};
 export class Socket extends GObject.GObject {
     static glibTypeName = "GSocket";
     static objectType = "gobject";
@@ -100,9 +94,6 @@ export class Socket extends GObject.GObject {
      * The protocol id is passed directly to the operating
      * system, so you can use protocols not listed in #GSocketProtocol if you
      * know the protocol number used for it.
-     * @param family - the socket family to use, e.g. %G_SOCKET_FAMILY_IPV4.
-     * @param type - the socket type to use.
-     * @param protocol - the id of the protocol to use, or 0 for default.
      */
     constructor(family, type, protocol) {
         if (!isInstantiating) {
@@ -112,18 +103,33 @@ export class Socket extends GObject.GObject {
             setInstantiating(false);
             this.id = call("libgio-2.0.so.0", "g_socket_new", [
                 {
-                    type: { type: "int", size: 32, unsigned: false },
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                     value: family,
+                    optional: false,
                 },
                 {
-                    type: { type: "int", size: 32, unsigned: false },
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                     value: type,
+                    optional: false,
                 },
                 {
-                    type: { type: "int", size: 32, unsigned: false },
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                     value: protocol,
+                    optional: false,
                 },
-            ], { type: "gobject", borrowed: false });
+            ], { type: "gobject", ownership: "full" });
         }
         else {
             // @ts-ignore
@@ -144,29 +150,38 @@ export class Socket extends GObject.GObject {
      *
      * Since GLib 2.46, it is no longer a fatal error to call this on a non-socket
      * descriptor.  Instead, a GError will be set with code %G_IO_ERROR_FAILED
-     * @param fd - a native socket file descriptor.
      */
     static newFromFd(fd) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_socket_new_from_fd", [
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: fd,
+                optional: false,
             },
             {
                 type: {
                     type: "ref",
                     innerType: {
                         type: "boxed",
+                        ownership: "full",
                         innerType: "GError",
-                        lib: "libglib-2.0.so.0",
+                        lib: "libgobject-2.0.so.0",
                     },
                 },
                 value: error,
+                optional: false,
             },
-        ], { type: "gobject", borrowed: false });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         if (error.value !== null) {
-            throw new NativeError(error.value);
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
         }
         return getNativeObject(ptr);
     }
@@ -181,18 +196,23 @@ export class Socket extends GObject.GObject {
      * If there are no outstanding connections then the operation will block
      * or return %G_IO_ERROR_WOULD_BLOCK if non-blocking I/O is enabled.
      * To be notified of an incoming connection, wait for the %G_IO_IN condition.
-     * @param cancellable - a %GCancellable or %NULL
      */
     accept(cancellable) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_socket_accept", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
                 optional: true,
             },
             {
@@ -200,15 +220,19 @@ export class Socket extends GObject.GObject {
                     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);
     }
@@ -236,22 +260,28 @@ export class Socket extends GObject.GObject {
      * same address, and they will all receive all of the multicast and
      * broadcast packets sent to that address. (The behavior of unicast
      * UDP packets to an address with multiple listeners is not defined.)
-     * @param address - a #GSocketAddress specifying the local address.
-     * @param allowReuse - whether to allow reusing this address
      */
     bind(address, allowReuse) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_bind", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: address?.id ?? address,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: address.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: allowReuse,
             },
             {
@@ -259,15 +289,18 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -280,7 +313,10 @@ export class Socket extends GObject.GObject {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_check_connect_result", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
@@ -288,15 +324,18 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -335,7 +374,10 @@ export class Socket extends GObject.GObject {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_close", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
@@ -343,15 +385,18 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -373,19 +418,29 @@ export class Socket extends GObject.GObject {
      * these conditions will always be set in the output if they are true.
      *
      * This call never blocks.
-     * @param condition - a #GIOCondition mask to check
      */
     conditionCheck(condition) {
         return call("libgio-2.0.so.0", "g_socket_condition_check", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: condition,
             },
-        ], { type: "int", size: 32, unsigned: true });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
     }
     /**
      * Waits for up to `timeout_us` microseconds for `condition` to become true
@@ -404,28 +459,39 @@ export class Socket extends GObject.GObject {
      * other GLib APIs, this function actually only has millisecond
      * resolution, and the behavior is undefined if `timeout_us` is not an
      * exact number of milliseconds.
-     * @param condition - a #GIOCondition mask to wait for
-     * @param timeoutUs - the maximum time (in microseconds) to wait, or -1
-     * @param cancellable - a #GCancellable, or %NULL
      */
     conditionTimedWait(condition, timeoutUs, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_condition_timed_wait", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: condition,
             },
             {
-                type: { type: "int", size: 64, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: false,
+                },
                 value: timeoutUs,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
                 optional: true,
             },
             {
@@ -433,15 +499,18 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -456,23 +525,31 @@ export class Socket extends GObject.GObject {
      * %G_IO_ERROR_TIMED_OUT).
      *
      * See also g_socket_condition_timed_wait().
-     * @param condition - a #GIOCondition mask to wait for
-     * @param cancellable - a #GCancellable, or %NULL
      */
     conditionWait(condition, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_condition_wait", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: condition,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
                 optional: true,
             },
             {
@@ -480,15 +557,18 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -509,23 +589,30 @@ export class Socket extends GObject.GObject {
      * and the user can be notified of the connection finishing by waiting
      * for the G_IO_OUT condition. The result of the connection must then be
      * checked with g_socket_check_connect_result().
-     * @param address - a #GSocketAddress specifying the remote address.
-     * @param cancellable - a %GCancellable or %NULL
      */
-    socketConnect(address, cancellable) {
+    SocketConnect(address, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_connect", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: address?.id ?? address,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: address.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
                 optional: true,
             },
             {
@@ -533,15 +620,18 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -552,10 +642,16 @@ export class Socket extends GObject.GObject {
     connectionFactoryCreateConnection() {
         const ptr = call("libgio-2.0.so.0", "g_socket_connection_factory_create_connection", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         return getNativeObject(ptr);
     }
     /**
@@ -575,10 +671,17 @@ export class Socket extends GObject.GObject {
     getAvailableBytes() {
         return call("libgio-2.0.so.0", "g_socket_get_available_bytes", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 64, unsigned: false });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: false,
+        });
     }
     /**
      * Gets the blocking mode of the socket. For details on blocking I/O,
@@ -587,10 +690,15 @@ export class Socket extends GObject.GObject {
     getBlocking() {
         return call("libgio-2.0.so.0", "g_socket_get_blocking", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Gets the broadcast setting on `socket`; if %TRUE,
@@ -600,10 +708,15 @@ export class Socket extends GObject.GObject {
     getBroadcast() {
         return call("libgio-2.0.so.0", "g_socket_get_broadcast", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Returns the credentials of the foreign process connected to this
@@ -631,7 +744,10 @@ export class Socket extends GObject.GObject {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_socket_get_credentials", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
@@ -639,28 +755,37 @@ export class Socket extends GObject.GObject {
                     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);
     }
-    /**
-     * Gets the socket family of the socket.
-     */
+    /** Gets the socket family of the socket. */
     getFamily() {
         return call("libgio-2.0.so.0", "g_socket_get_family", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Returns the underlying OS socket object. On unix this
@@ -672,10 +797,17 @@ export class Socket extends GObject.GObject {
     getFd() {
         return call("libgio-2.0.so.0", "g_socket_get_fd", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Gets the keepalive mode of the socket. For details on this,
@@ -684,10 +816,15 @@ export class Socket extends GObject.GObject {
     getKeepalive() {
         return call("libgio-2.0.so.0", "g_socket_get_keepalive", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Gets the listen backlog setting of the socket. For details on this,
@@ -696,10 +833,17 @@ export class Socket extends GObject.GObject {
     getListenBacklog() {
         return call("libgio-2.0.so.0", "g_socket_get_listen_backlog", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Try to get the local address of a bound socket. This is only
@@ -710,7 +854,10 @@ export class Socket extends GObject.GObject {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_socket_get_local_address", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
@@ -718,15 +865,19 @@ export class Socket extends GObject.GObject {
                     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);
     }
@@ -738,10 +889,15 @@ export class Socket extends GObject.GObject {
     getMulticastLoopback() {
         return call("libgio-2.0.so.0", "g_socket_get_multicast_loopback", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Gets the multicast time-to-live setting on `socket`; see
@@ -750,10 +906,17 @@ export class Socket extends GObject.GObject {
     getMulticastTtl() {
         return call("libgio-2.0.so.0", "g_socket_get_multicast_ttl", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: true });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
     }
     /**
      * Gets the value of an integer-valued option on `socket`, as with
@@ -769,29 +932,41 @@ export class Socket extends GObject.GObject {
      * Note that even for socket options that are a single byte in size,
      * `value` is still a pointer to a #gint variable, not a #guchar;
      * g_socket_get_option() will handle the conversion internally.
-     * @param level - the "API level" of the option (eg, `SOL_SOCKET`)
-     * @param optname - the "name" of the option (eg, `SO_BROADCAST`)
-     * @param value - return location for the option value
      */
     getOption(level, optname, value) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_get_option", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: level,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: optname,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: value,
             },
@@ -800,15 +975,18 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -819,10 +997,17 @@ export class Socket extends GObject.GObject {
     getProtocol() {
         return call("libgio-2.0.so.0", "g_socket_get_protocol", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Try to get the remote address of a connected socket. This is only
@@ -832,7 +1017,10 @@ export class Socket extends GObject.GObject {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_socket_get_remote_address", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
@@ -840,28 +1028,37 @@ export class Socket extends GObject.GObject {
                     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);
     }
-    /**
-     * Gets the socket type of the socket.
-     */
+    /** Gets the socket type of the socket. */
     getSocketType() {
         return call("libgio-2.0.so.0", "g_socket_get_socket_type", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Gets the timeout setting of the socket. For details on this, see
@@ -870,10 +1067,17 @@ export class Socket extends GObject.GObject {
     getTimeout() {
         return call("libgio-2.0.so.0", "g_socket_get_timeout", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: true });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
     }
     /**
      * Gets the unicast time-to-live setting on `socket`; see
@@ -882,21 +1086,31 @@ export class Socket extends GObject.GObject {
     getTtl() {
         return call("libgio-2.0.so.0", "g_socket_get_ttl", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 32, unsigned: true });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
     }
-    /**
-     * Checks whether a socket is closed.
-     */
+    /** Checks whether a socket is closed. */
     isClosed() {
         return call("libgio-2.0.so.0", "g_socket_is_closed", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Check whether the socket is connected. This is only useful for
@@ -910,10 +1124,15 @@ export class Socket extends GObject.GObject {
     isConnected() {
         return call("libgio-2.0.so.0", "g_socket_is_connected", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Registers `socket` to receive multicast messages sent to `group`.
@@ -930,27 +1149,35 @@ export class Socket extends GObject.GObject {
      *
      * To bind to a given source-specific multicast address, use
      * g_socket_join_multicast_group_ssm() instead.
-     * @param group - a #GInetAddress specifying the group address to join.
-     * @param sourceSpecific - %TRUE if source-specific multicast should be used
-     * @param iface - Name of the interface to use, or %NULL
      */
     joinMulticastGroup(group, sourceSpecific, iface) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_join_multicast_group", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: group?.id ?? group,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: group.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: sourceSpecific,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: iface,
                 optional: true,
             },
@@ -959,15 +1186,18 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -987,28 +1217,37 @@ export class Socket extends GObject.GObject {
      * Note that this function can be called multiple times for the same
      * `group` with different `source_specific` in order to receive multicast
      * packets from more than one source.
-     * @param group - a #GInetAddress specifying the group address to join.
-     * @param sourceSpecific - a #GInetAddress specifying the
-     * @param iface - Name of the interface to use, or %NULL
      */
     joinMulticastGroupSsm(group, sourceSpecific, iface) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_join_multicast_group_ssm", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: group?.id ?? group,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: group.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: sourceSpecific?.id ?? sourceSpecific,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: sourceSpecific?.id,
                 optional: true,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: iface,
                 optional: true,
             },
@@ -1017,15 +1256,18 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -1039,27 +1281,35 @@ export class Socket extends GObject.GObject {
      *
      * To unbind to a given source-specific multicast address, use
      * g_socket_leave_multicast_group_ssm() instead.
-     * @param group - a #GInetAddress specifying the group address to leave.
-     * @param sourceSpecific - %TRUE if source-specific multicast was used
-     * @param iface - Interface used
      */
     leaveMulticastGroup(group, sourceSpecific, iface) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_leave_multicast_group", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: group?.id ?? group,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: group.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: sourceSpecific,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: iface,
                 optional: true,
             },
@@ -1068,15 +1318,18 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -1087,28 +1340,37 @@ export class Socket extends GObject.GObject {
      *
      * `socket` remains bound to its address and port, and can still receive
      * unicast messages after calling this.
-     * @param group - a #GInetAddress specifying the group address to leave.
-     * @param sourceSpecific - a #GInetAddress specifying the
-     * @param iface - Name of the interface to use, or %NULL
      */
     leaveMulticastGroupSsm(group, sourceSpecific, iface) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_leave_multicast_group_ssm", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: group?.id ?? group,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: group.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: sourceSpecific?.id ?? sourceSpecific,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: sourceSpecific?.id,
                 optional: true,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: iface,
                 optional: true,
             },
@@ -1117,15 +1379,18 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -1143,7 +1408,10 @@ export class Socket extends GObject.GObject {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_listen", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
@@ -1151,15 +1419,18 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -1187,15 +1458,15 @@ export class Socket extends GObject.GObject {
      * %G_IO_IN condition.
      *
      * On error -1 is returned and `error` is set accordingly.
-     * @param buffer - a buffer to read data into (which should be at least `size` bytes long).
-     * @param size - the number of bytes you want to read from the socket
-     * @param cancellable - a %GCancellable or %NULL
      */
     receive(buffer, size, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_receive", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
@@ -1203,18 +1474,31 @@ export class Socket extends GObject.GObject {
                     type: "ref",
                     innerType: {
                         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: size,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
                 optional: true,
             },
             {
@@ -1222,15 +1506,20 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -1244,28 +1533,39 @@ export class Socket extends GObject.GObject {
      * the connection is closed, or there is an error). Pass `0` to use the default
      * timeout from {@link Gio.Socket.timeout}, or pass a positive number to wait
      * for that many microseconds for data before returning `G_IO_ERROR_TIMED_OUT`.
-     * @param size - the number of bytes you want to read from the socket
-     * @param timeoutUs - the timeout to wait for, in microseconds, or `-1` to block
-     * @param cancellable - a %GCancellable, or `NULL`
      */
     receiveBytes(size, timeoutUs, cancellable) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_socket_receive_bytes", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: size,
             },
             {
-                type: { type: "int", size: 64, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: false,
+                },
                 value: timeoutUs,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
                 optional: true,
             },
             {
@@ -1273,21 +1573,22 @@ export class Socket extends GObject.GObject {
                     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);
     }
@@ -1306,34 +1607,50 @@ export class Socket extends GObject.GObject {
      * the connection is closed, or there is an error). Pass `0` to use the default
      * timeout from {@link Gio.Socket.timeout}, or pass a positive number to wait
      * for that many microseconds for data before returning `G_IO_ERROR_TIMED_OUT`.
-     * @param address - return location for a #GSocketAddress
-     * @param size - the number of bytes you want to read from the socket
-     * @param timeoutUs - the timeout to wait for, in microseconds, or `-1` to block
-     * @param cancellable - a #GCancellable, or `NULL`
      */
     receiveBytesFrom(size, timeoutUs, address, cancellable) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_socket_receive_bytes_from", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "ref", innerType: { type: "gobject" } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "gobject",
+                        ownership: "full",
+                    },
+                },
                 value: address,
                 optional: true,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: size,
             },
             {
-                type: { type: "int", size: 64, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: false,
+                },
                 value: timeoutUs,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
                 optional: true,
             },
             {
@@ -1341,21 +1658,22 @@ export class Socket extends GObject.GObject {
                     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));
         }
         if (address)
             address.value = getNativeObject(address.value);
@@ -1369,20 +1687,25 @@ export class Socket extends GObject.GObject {
      * `address` is owned by the caller.
      *
      * See g_socket_receive() for additional information.
-     * @param address - a pointer to a #GSocketAddress
-     * @param buffer - a buffer to read data into (which should be at least `size` bytes long).
-     * @param size - the number of bytes you want to read from the socket
-     * @param cancellable - a %GCancellable or %NULL
      */
     receiveFrom(buffer, size, address, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_receive_from", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "ref", innerType: { type: "gobject" } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "gobject",
+                        ownership: "full",
+                    },
+                },
                 value: address,
                 optional: true,
             },
@@ -1391,18 +1714,31 @@ export class Socket extends GObject.GObject {
                     type: "ref",
                     innerType: {
                         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: size,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
                 optional: true,
             },
             {
@@ -1410,15 +1746,20 @@ export class Socket extends GObject.GObject {
                     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));
         }
         if (address)
             address.value = getNativeObject(address.value);
@@ -1484,41 +1825,61 @@ export class Socket extends GObject.GObject {
      * %G_IO_IN condition.
      *
      * On error -1 is returned and `error` is set accordingly.
-     * @param address - a pointer to a #GSocketAddress
-     * @param vectors - an array of #GInputVector structs
-     * @param numVectors - the number of elements in `vectors`, or -1
-     * @param messages - a pointer
-     * @param numMessages - a pointer which will be filled with the number of
-     * @param flags - a pointer to an int containing #GSocketMsgFlags flags,
-     * @param cancellable - a %GCancellable or %NULL
      */
     receiveMessage(vectors, numVectors, numMessages, flags, address, messages, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_receive_message", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "ref", innerType: { type: "gobject" } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "gobject",
+                        ownership: "full",
+                    },
+                },
                 value: address,
                 optional: true,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 64, unsigned: true },
+                    itemType: {
+                        type: "struct",
+                        ownership: "none",
+                        innerType: "InputVector",
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: vectors,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: numVectors,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "array", itemType: { type: "gobject" } },
+                    innerType: {
+                        type: "array",
+                        itemType: {
+                            type: "gobject",
+                            ownership: "full",
+                        },
+                        listType: "array",
+                        ownership: "full",
+                    },
                 },
                 value: messages,
                 optional: true,
@@ -1526,20 +1887,31 @@ export class Socket extends GObject.GObject {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: numMessages,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: flags,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
                 optional: true,
             },
             {
@@ -1547,15 +1919,20 @@ export class Socket extends GObject.GObject {
                     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));
         }
         if (address)
             address.value = getNativeObject(address.value);
@@ -1610,36 +1987,52 @@ export class Socket extends GObject.GObject {
      * On error -1 is returned and `error` is set accordingly. An error will only
      * be returned if zero messages could be received; otherwise the number of
      * messages successfully received before the error will be returned.
-     * @param messages - an array of #GInputMessage structs
-     * @param numMessages - the number of elements in `messages`
-     * @param flags - an int containing #GSocketMsgFlags flags for the overall operation,
-     * @param cancellable - a %GCancellable or %NULL
      */
     receiveMessages(messages, numMessages, flags, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_receive_messages", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 64, unsigned: true },
+                    itemType: {
+                        type: "struct",
+                        ownership: "none",
+                        innerType: "InputMessage",
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: messages,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: numMessages,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: flags,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
                 optional: true,
             },
             {
@@ -1647,15 +2040,20 @@ export class Socket extends GObject.GObject {
                     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: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
         if (error.value !== null) {
-            throw new NativeError(error.value);
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
         }
         return result;
     }
@@ -1663,16 +2061,15 @@ export class Socket extends GObject.GObject {
      * This behaves exactly the same as g_socket_receive(), except that
      * the choice of blocking or non-blocking behavior is determined by
      * the `blocking` argument rather than by `socket`'s properties.
-     * @param buffer - a buffer to read data into (which should be at least `size` bytes long).
-     * @param size - the number of bytes you want to read from the socket
-     * @param blocking - whether to do blocking or non-blocking I/O
-     * @param cancellable - a %GCancellable or %NULL
      */
     receiveWithBlocking(buffer, size, blocking, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_receive_with_blocking", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
@@ -1680,22 +2077,37 @@ export class Socket extends GObject.GObject {
                     type: "ref",
                     innerType: {
                         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: size,
             },
             {
-                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,
             },
             {
@@ -1703,15 +2115,20 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -1730,31 +2147,44 @@ export class Socket extends GObject.GObject {
      * very common due to the way the underlying APIs work.)
      *
      * On error -1 is returned and `error` is set accordingly.
-     * @param buffer - the buffer
-     * @param size - the number of bytes to send
-     * @param cancellable - a %GCancellable or %NULL
      */
     send(buffer, size, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_send", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.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: size,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
                 optional: true,
             },
             {
@@ -1762,15 +2192,20 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -1817,53 +2252,81 @@ export class Socket extends GObject.GObject {
      * function.
      *
      * On error -1 is returned and `error` is set accordingly.
-     * @param address - a #GSocketAddress, or %NULL
-     * @param vectors - an array of #GOutputVector structs
-     * @param numVectors - the number of elements in `vectors`, or -1
-     * @param messages - a pointer to an
-     * @param numMessages - number of elements in `messages`, or -1.
-     * @param flags - an int containing #GSocketMsgFlags flags, which may additionally
-     * @param cancellable - a %GCancellable or %NULL
      */
     sendMessage(vectors, numVectors, numMessages, flags, address, messages, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_send_message", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: address?.id ?? address,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: address?.id,
                 optional: true,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 64, unsigned: true },
+                    itemType: {
+                        type: "struct",
+                        ownership: "none",
+                        innerType: "OutputVector",
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: vectors,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: numVectors,
             },
             {
-                type: { type: "array", itemType: { type: "gobject" } },
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    listType: "array",
+                    ownership: "none",
+                },
                 value: messages,
                 optional: true,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: numMessages,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: flags,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
                 optional: true,
             },
             {
@@ -1871,15 +2334,20 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -1891,67 +2359,101 @@ export class Socket extends GObject.GObject {
      * On error %G_POLLABLE_RETURN_FAILED is returned and `error` is set accordingly, or
      * if the socket is currently not writable %G_POLLABLE_RETURN_WOULD_BLOCK is
      * returned. `bytes_written` will contain 0 in both cases.
-     * @param address - a #GSocketAddress, or %NULL
-     * @param vectors - an array of #GOutputVector structs
-     * @param numVectors - the number of elements in `vectors`, or -1
-     * @param messages - a pointer to an
-     * @param numMessages - number of elements in `messages`, or -1.
-     * @param flags - an int containing #GSocketMsgFlags flags, which may additionally
-     * @param timeoutUs - the maximum time (in microseconds) to wait, or -1
-     * @param bytesWritten - location to store the number of bytes that were written to the socket
-     * @param cancellable - a %GCancellable or %NULL
      */
     sendMessageWithTimeout(vectors, numVectors, numMessages, flags, timeoutUs, address, messages, bytesWritten, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_send_message_with_timeout", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: address?.id ?? address,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: address?.id,
                 optional: true,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 64, unsigned: true },
+                    itemType: {
+                        type: "struct",
+                        ownership: "none",
+                        innerType: "OutputVector",
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: vectors,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: numVectors,
             },
             {
-                type: { type: "array", itemType: { type: "gobject" } },
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    listType: "array",
+                    ownership: "none",
+                },
                 value: messages,
                 optional: true,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: numMessages,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: flags,
             },
             {
-                type: { type: "int", size: 64, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: false,
+                },
                 value: timeoutUs,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
                 },
                 value: bytesWritten,
                 optional: true,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
                 optional: true,
             },
             {
@@ -1959,15 +2461,20 @@ export class Socket extends GObject.GObject {
                     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: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
         if (error.value !== null) {
-            throw new NativeError(error.value);
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
         }
         return result;
     }
@@ -2006,36 +2513,52 @@ export class Socket extends GObject.GObject {
      * On error -1 is returned and `error` is set accordingly. An error will only
      * be returned if zero messages could be sent; otherwise the number of messages
      * successfully sent before the error will be returned.
-     * @param messages - an array of #GOutputMessage structs
-     * @param numMessages - the number of elements in `messages`
-     * @param flags - an int containing #GSocketMsgFlags flags, which may additionally
-     * @param cancellable - a %GCancellable or %NULL
      */
     sendMessages(messages, numMessages, flags, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_send_messages", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "int", size: 64, unsigned: true },
+                    itemType: {
+                        type: "struct",
+                        ownership: "none",
+                        innerType: "OutputMessage",
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: messages,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: numMessages,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: flags,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
                 optional: true,
             },
             {
@@ -2043,15 +2566,20 @@ export class Socket extends GObject.GObject {
                     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: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
         if (error.value !== null) {
-            throw new NativeError(error.value);
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
         }
         return result;
     }
@@ -2061,37 +2589,52 @@ export class Socket extends GObject.GObject {
      * g_socket_connect()).
      *
      * See g_socket_send() for additional information.
-     * @param address - a #GSocketAddress, or %NULL
-     * @param buffer - the buffer
-     * @param size - the number of bytes to send
-     * @param cancellable - a %GCancellable or %NULL
      */
     sendTo(buffer, size, address, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_send_to", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: address?.id ?? address,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: address?.id,
                 optional: true,
             },
             {
                 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: size,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
                 optional: true,
             },
             {
@@ -2099,15 +2642,20 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -2115,36 +2663,50 @@ export class Socket extends GObject.GObject {
      * This behaves exactly the same as g_socket_send(), except that
      * the choice of blocking or non-blocking behavior is determined by
      * the `blocking` argument rather than by `socket`'s properties.
-     * @param buffer - the buffer
-     * @param size - the number of bytes to send
-     * @param blocking - whether to do blocking or non-blocking I/O
-     * @param cancellable - a %GCancellable or %NULL
      */
     sendWithBlocking(buffer, size, blocking, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_send_with_blocking", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.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: size,
             },
             {
-                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,
             },
             {
@@ -2152,15 +2714,20 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -2174,36 +2741,48 @@ export class Socket extends GObject.GObject {
      * All sockets are created in blocking mode. However, note that the
      * platform level socket is always non-blocking, and blocking mode
      * is a GSocket level feature.
-     * @param blocking - Whether to use blocking I/O or not.
      */
     setBlocking(blocking) {
         call("libgio-2.0.so.0", "g_socket_set_blocking", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: blocking,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets whether `socket` should allow sending to broadcast addresses.
      * This is %FALSE by default.
-     * @param broadcast - whether `socket` should allow sending to broadcast
      */
     setBroadcast(broadcast) {
         call("libgio-2.0.so.0", "g_socket_set_broadcast", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: broadcast,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets or unsets the %SO_KEEPALIVE flag on the underlying socket. When
@@ -2221,19 +2800,25 @@ export class Socket extends GObject.GObject {
      * on a server socket if you want to allow clients to remain idle for long
      * periods of time, but also want to ensure that connections are eventually
      * garbage-collected if clients crash or become unreachable.
-     * @param keepalive - Value for the keepalive flag
      */
     setKeepalive(keepalive) {
         call("libgio-2.0.so.0", "g_socket_set_keepalive", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: keepalive,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the maximum number of outstanding connections allowed
@@ -2243,55 +2828,77 @@ export class Socket extends GObject.GObject {
      *
      * Note that this must be called before g_socket_listen() and has no
      * effect if called after that.
-     * @param backlog - the maximum number of pending connections.
      */
     setListenBacklog(backlog) {
         call("libgio-2.0.so.0", "g_socket_set_listen_backlog", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: backlog,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets whether outgoing multicast packets will be received by sockets
      * listening on that multicast address on the same host. This is %TRUE
      * by default.
-     * @param loopback - whether `socket` should receive messages sent to its
      */
     setMulticastLoopback(loopback) {
         call("libgio-2.0.so.0", "g_socket_set_multicast_loopback", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: loopback,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the time-to-live for outgoing multicast datagrams on `socket`.
      * By default, this is 1, meaning that multicast packets will not leave
      * the local network.
-     * @param ttl - the time-to-live value for all multicast datagrams on `socket`
      */
     setMulticastTtl(ttl) {
         call("libgio-2.0.so.0", "g_socket_set_multicast_ttl", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: ttl,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the value of an integer-valued option on `socket`, as with
@@ -2303,27 +2910,39 @@ export class Socket extends GObject.GObject {
      * standard/portable socket options. For unusual socket protocols or
      * platform-dependent options, you may need to include additional
      * headers.
-     * @param level - the "API level" of the option (eg, `SOL_SOCKET`)
-     * @param optname - the "name" of the option (eg, `SO_BROADCAST`)
-     * @param value - the value to set the option to
      */
     setOption(level, optname, value) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_set_option", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: level,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: optname,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: value,
             },
             {
@@ -2331,15 +2950,18 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -2364,36 +2986,52 @@ export class Socket extends GObject.GObject {
      *
      * Note that if an I/O operation is interrupted by a signal, this may
      * cause the timeout to be reset.
-     * @param timeout - the timeout for `socket`, in seconds, or 0 for none
      */
     setTimeout(timeout) {
         call("libgio-2.0.so.0", "g_socket_set_timeout", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: timeout,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the time-to-live for outgoing unicast packets on `socket`.
      * By default the platform-specific default value is used.
-     * @param ttl - the time-to-live value for all unicast packets on `socket`
      */
     setTtl(ttl) {
         call("libgio-2.0.so.0", "g_socket_set_ttl", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: ttl,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Shut down part or all of a full-duplex connection.
@@ -2410,22 +3048,27 @@ export class Socket extends GObject.GObject {
      * graceful disconnect for TCP connections where you close the sending side,
      * then wait for the other side to close the connection, thus ensuring that the
      * other side saw all sent data.
-     * @param shutdownRead - whether to shut down the read side
-     * @param shutdownWrite - whether to shut down the write side
      */
     shutdown(shutdownRead, shutdownWrite) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_socket_shutdown", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: shutdownRead,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: shutdownWrite,
             },
             {
@@ -2433,15 +3076,18 @@ export class Socket extends GObject.GObject {
                     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;
     }
@@ -2459,10 +3105,15 @@ export class Socket extends GObject.GObject {
     speaksIpv4() {
         return call("libgio-2.0.so.0", "g_socket_speaks_ipv4", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Creates a #GSource that can be attached to a #GMainContext to monitor for
@@ -2479,27 +3130,35 @@ export class Socket extends GObject.GObject {
      * likely 0 unless cancellation happened at the same time as a condition
      * change). You can check for this in the callback using
      * g_cancellable_is_cancelled().
-     * @param condition - a #GIOCondition mask to monitor
-     * @param cancellable - a #GCancellable
      */
     createSource(condition, cancellable) {
         const ptr = call("libgio-2.0.so.0", "g_datagram_based_create_source", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: condition,
             },
             {
-                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",
@@ -2545,18 +3204,23 @@ export class Socket extends GObject.GObject {
      * In this pattern, a caller would expect to be able to call g_initable_init()
      * on the result of g_object_new(), regardless of whether it is in fact a new
      * instance.
-     * @param cancellable - optional #GCancellable object, %NULL to ignore.
      */
     init(cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_initable_init", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
                 optional: true,
             },
             {
@@ -2564,49 +3228,20 @@ export class Socket extends GObject.GObject {
                     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;
     }
-    connect(signal, handler, after = false) {
-        const meta = SIGNAL_META[signal];
-        const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
-        const returnType = meta?.returnType;
-        const wrappedHandler = (...args) => {
-            const self = getNativeObject(args[0]);
-            const callbackArgs = args.slice(1);
-            if (!meta)
-                return handler(self, ...callbackArgs);
-            const wrapped = meta.params.map((t, i) => {
-                if (t?.type === "gobject" && callbackArgs[i] != null) {
-                    return getNativeObject(callbackArgs[i]);
-                }
-                if (t?.type === "gparam" && callbackArgs[i] != null) {
-                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
-                }
-                return callbackArgs[i];
-            });
-            const result = handler(self, ...wrapped);
-            return result;
-        };
-        return call("libgio-2.0.so.0", "g_signal_connect_closure", [
-            { type: { type: "gobject" }, value: this.id },
-            { type: { type: "string" }, value: signal },
-            {
-                type: { type: "callback", argTypes, returnType },
-                value: wrappedHandler,
-            },
-            { type: { type: "boolean" }, value: after },
-        ], { type: "int", size: 64, unsigned: true });
-    }
 }
 registerNativeClass(Socket);