@gtkx/ffi 0.10.5 → 0.11.0

package/dist/generated/soup/functions.js

@@ -9,25 +9,36 @@ import * as GLib from "../glib/index.js";
  *
  * This is useful for compiling against older versions of libsoup, but using
  * features from newer versions.
- * @param major - the major version to check
- * @param minor - the minor version to check
- * @param micro - the micro version to check
  */
 export const checkVersion = (major, minor, micro) => {
     return call("libsoup-3.0.so.0", "soup_check_version", [
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: major,
         },
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: minor,
         },
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: micro,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
 /**
  * Parses `header` and returns a #SoupCookie.
@@ -43,29 +54,30 @@ export const checkVersion = (major, minor, micro) => {
  *
  * As of version 3.4.0 the default value of a cookie's same-site-policy
  * is %SOUP_SAME_SITE_POLICY_LAX.
- * @param header - a cookie string (eg, the value of a Set-Cookie header)
- * @param origin - origin of the cookie
  */
 export const cookieParse = (header, origin) => {
     const ptr = call("libsoup-3.0.so.0", "soup_cookie_parse", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: header,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GUri",
                 lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                 getTypeFn: "g_uri_get_type",
             },
-            value: origin?.id ?? origin,
+            value: origin?.id,
             optional: true,
         },
     ], {
         type: "boxed",
-        borrowed: true,
+        ownership: "full",
         innerType: "SoupCookie",
         lib: "libsoup-3.0.so.0",
         getTypeFn: "soup_cookie_get_type",
@@ -82,26 +94,29 @@ export const cookieParse = (header, origin) => {
  * values, none of the other #SoupCookie fields will be filled in. (Thus, you
  * can't generally pass a cookie returned from this method directly to
  * {@link cookies_to_response}.)
- * @param msg - a #SoupMessage containing a "Cookie" request header
  */
 export const cookiesFromRequest = (msg) => {
-    return call("libsoup-3.0.so.0", "soup_cookies_from_request", [
+    const arr = call("libsoup-3.0.so.0", "soup_cookies_from_request", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: msg?.id ?? msg,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: msg.id,
         },
     ], {
         type: "array",
         itemType: {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "SoupCookie",
             lib: "libsoup-3.0.so.0",
             getTypeFn: "soup_cookie_get_type",
         },
         listType: "gslist",
-        borrowed: true,
+        ownership: "full",
     });
+    return arr.map((item) => getNativeObject(item));
 };
 /**
  * Parses `msg`'s Set-Cookie response headers and returns a {@link GLib.SList}
@@ -109,31 +124,33 @@ export const cookiesFromRequest = (msg) => {
  *
  * Cookies that do not specify "path" or "domain" attributes will have their
  * values defaulted from `msg`.
- * @param msg - a #SoupMessage containing a "Set-Cookie" response header
  */
 export const cookiesFromResponse = (msg) => {
-    return call("libsoup-3.0.so.0", "soup_cookies_from_response", [
+    const arr = call("libsoup-3.0.so.0", "soup_cookies_from_response", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: msg?.id ?? msg,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: msg.id,
         },
     ], {
         type: "array",
         itemType: {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "SoupCookie",
             lib: "libsoup-3.0.so.0",
             getTypeFn: "soup_cookie_get_type",
         },
         listType: "gslist",
-        borrowed: true,
+        ownership: "full",
     });
+    return arr.map((item) => getNativeObject(item));
 };
 /**
  * Serializes a {@link GLib.SList} of #SoupCookie into a string suitable for
  * setting as the value of the "Cookie" header.
- * @param cookies - a #GSList of #SoupCookie
  */
 export const cookiesToCookieHeader = (cookies) => {
     return call("libsoup-3.0.so.0", "soup_cookies_to_cookie_header", [
@@ -142,15 +159,20 @@ export const cookiesToCookieHeader = (cookies) => {
                 type: "array",
                 itemType: {
                     type: "boxed",
+                    ownership: "none",
                     innerType: "SoupCookie",
                     lib: "libsoup-3.0.so.0",
                     getTypeFn: "soup_cookie_get_type",
                 },
                 listType: "gslist",
+                ownership: "none",
             },
             value: cookies,
         },
-    ], { type: "string" });
+    ], {
+        type: "string",
+        ownership: "full",
+    });
 };
 /**
  * Adds the name and value of each cookie in `cookies` to `msg`'s
@@ -159,8 +181,6 @@ export const cookiesToCookieHeader = (cookies) => {
  * If `msg` already has a "Cookie" request header, these cookies will be appended
  * to the cookies already present. Be careful that you do not append the same
  * cookies twice, eg, when requeuing a message.
- * @param cookies - a #GSList of #SoupCookie
- * @param msg - a #SoupMessage
  */
 export const cookiesToRequest = (cookies, msg) => {
     call("libsoup-3.0.so.0", "soup_cookies_to_request", [
@@ -169,19 +189,26 @@ export const cookiesToRequest = (cookies, msg) => {
                 type: "array",
                 itemType: {
                     type: "boxed",
+                    ownership: "none",
                     innerType: "SoupCookie",
                     lib: "libsoup-3.0.so.0",
                     getTypeFn: "soup_cookie_get_type",
                 },
                 listType: "gslist",
+                ownership: "none",
             },
             value: cookies,
         },
         {
-            type: { type: "gobject", borrowed: true },
-            value: msg?.id ?? msg,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: msg.id,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
 };
 /**
  * Appends a "Set-Cookie" response header to `msg` for each cookie in
@@ -189,8 +216,6 @@ export const cookiesToRequest = (cookies, msg) => {
  *
  * This is in addition to any other "Set-Cookie" headers
  * `msg` may already have.
- * @param cookies - a #GSList of #SoupCookie
- * @param msg - a #SoupMessage
  */
 export const cookiesToResponse = (cookies, msg) => {
     call("libsoup-3.0.so.0", "soup_cookies_to_response", [
@@ -199,19 +224,26 @@ export const cookiesToResponse = (cookies, msg) => {
                 type: "array",
                 itemType: {
                     type: "boxed",
+                    ownership: "none",
                     innerType: "SoupCookie",
                     lib: "libsoup-3.0.so.0",
                     getTypeFn: "soup_cookie_get_type",
                 },
                 listType: "gslist",
+                ownership: "none",
             },
             value: cookies,
         },
         {
-            type: { type: "gobject", borrowed: true },
-            value: msg?.id ?? msg,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: msg.id,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
 };
 /**
  * Parses `date_string` and tries to extract a date from it.
@@ -219,17 +251,19 @@ export const cookiesToResponse = (cookies, msg) => {
  * This recognizes all of the "HTTP-date" formats from RFC 2616, RFC 2822 dates,
  * and reasonable approximations thereof. (Eg, it is lenient about whitespace,
  * leading "0"s, etc.)
- * @param dateString - The date as a string
  */
 export const dateTimeNewFromHttpString = (dateString) => {
     const ptr = call("libsoup-3.0.so.0", "soup_date_time_new_from_http_string", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: dateString,
         },
     ], {
         type: "boxed",
-        borrowed: true,
+        ownership: "full",
         innerType: "GDateTime",
         lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
         getTypeFn: "g_date_time_get_type",
@@ -238,49 +272,60 @@ export const dateTimeNewFromHttpString = (dateString) => {
         return null;
     return getNativeObject(ptr, GLib.DateTime);
 };
-/**
- * Converts `date` to a string in the format described by `format`.
- * @param date - a #GDateTime
- * @param format - the format to generate the date in
- */
+/** Converts `date` to a string in the format described by `format`. */
 export const dateTimeToString = (date, format) => {
     return call("libsoup-3.0.so.0", "soup_date_time_to_string", [
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GDateTime",
                 lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                 getTypeFn: "g_date_time_get_type",
             },
-            value: date?.id ?? date,
+            value: date.id,
         },
         {
-            type: { type: "int", size: 32, unsigned: false },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
             value: format,
         },
-    ], { type: "string" });
+    ], {
+        type: "string",
+        ownership: "full",
+    });
 };
 /**
  * Decodes `form`.
  *
  * which is an urlencoded dataset as defined in the HTML 4.01 spec.
- * @param encodedForm - data of type "application/x-www-form-urlencoded"
  */
 export const formDecode = (encodedForm) => {
-    const ptr = call("libsoup-3.0.so.0", "soup_form_decode", [
+    const tuples = call("libsoup-3.0.so.0", "soup_form_decode", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: encodedForm,
         },
     ], {
-        type: "boxed",
-        borrowed: true,
-        innerType: "GHashTable",
-        lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-        getTypeFn: "g_hash_table_get_type",
+        type: "hashtable",
+        keyType: {
+            type: "string",
+            ownership: "full",
+        },
+        valueType: {
+            type: "string",
+            ownership: "full",
+        },
+        listType: "ghashtable",
+        ownership: "none",
     });
-    return getNativeObject(ptr, GLib.HashTable);
+    return new Map(tuples);
 };
 /**
  * Decodes the "multipart/form-data" request in `multipart`.
@@ -302,35 +347,46 @@ export const formDecode = (encodedForm) => {
  * If you have a form with more than one file upload control, you will
  * need to decode it manually, using {@link Multipart.new_from_message}
  * and {@link Multipart.get_part}.
- * @param multipart - a #SoupMultipart
- * @param fileControlName - the name of the HTML file upload control
- * @param filename - return location for the name of the uploaded file
- * @param contentType - return location for the MIME type of the uploaded file
- * @param file - return location for the uploaded file data
  */
 export const formDecodeMultipart = (multipart, fileControlName, filename, contentType, file) => {
-    const ptr = call("libsoup-3.0.so.0", "soup_form_decode_multipart", [
+    const tuples = call("libsoup-3.0.so.0", "soup_form_decode_multipart", [
         {
             type: {
                 type: "boxed",
+                ownership: "full",
                 innerType: "SoupMultipart",
                 lib: "libsoup-3.0.so.0",
                 getTypeFn: "soup_multipart_get_type",
             },
-            value: multipart?.id ?? multipart,
+            value: multipart.id,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: fileControlName,
             optional: true,
         },
         {
-            type: { type: "ref", innerType: { type: "string" } },
+            type: {
+                type: "ref",
+                innerType: {
+                    type: "string",
+                    ownership: "full",
+                },
+            },
             value: filename,
             optional: true,
         },
         {
-            type: { type: "ref", innerType: { type: "string" } },
+            type: {
+                type: "ref",
+                innerType: {
+                    type: "string",
+                    ownership: "full",
+                },
+            },
             value: contentType,
             optional: true,
         },
@@ -339,6 +395,7 @@ export const formDecodeMultipart = (multipart, fileControlName, filename, conten
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GBytes",
                     lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                     getTypeFn: "g_bytes_get_type",
@@ -348,17 +405,23 @@ export const formDecodeMultipart = (multipart, fileControlName, filename, conten
             optional: true,
         },
     ], {
-        type: "boxed",
-        borrowed: true,
-        innerType: "GHashTable",
-        lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-        getTypeFn: "g_hash_table_get_type",
+        type: "hashtable",
+        keyType: {
+            type: "string",
+            ownership: "full",
+        },
+        valueType: {
+            type: "string",
+            ownership: "full",
+        },
+        listType: "ghashtable",
+        ownership: "none",
     });
     if (file)
         file.value = getNativeObject(file.value, GLib.Bytes);
-    if (ptr === null)
+    if (tuples === null)
         return null;
-    return getNativeObject(ptr, GLib.HashTable);
+    return new Map(tuples);
 };
 /**
  * Encodes `form_data_set` into a value of type
@@ -369,15 +432,21 @@ export const formDecodeMultipart = (multipart, fileControlName, filename, conten
  * some situations.
  *
  * See also: {@link Message.new_from_encoded_form}.
- * @param formDataSet - a datalist containing name/value pairs
  */
 export const formEncodeDatalist = (formDataSet) => {
     return call("libsoup-3.0.so.0", "soup_form_encode_datalist", [
         {
-            type: { type: "int", size: 64, unsigned: true },
-            value: formDataSet,
+            type: {
+                type: "struct",
+                ownership: "none",
+                innerType: "Data",
+            },
+            value: formDataSet.id,
         },
-    ], { type: "string" });
+    ], {
+        type: "string",
+        ownership: "full",
+    });
 };
 /**
  * Encodes `form_data_set` into a value of type
@@ -391,21 +460,29 @@ export const formEncodeDatalist = (formDataSet) => {
  * ordering of the form fields, use {@link form_encode_datalist}.
  *
  * See also: {@link Message.new_from_encoded_form}.
- * @param formDataSet - a hash table containing
  */
 export const formEncodeHash = (formDataSet) => {
     return call("libsoup-3.0.so.0", "soup_form_encode_hash", [
         {
             type: {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GHashTable",
-                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                getTypeFn: "g_hash_table_get_type",
+                type: "hashtable",
+                keyType: {
+                    type: "string",
+                    ownership: "none",
+                },
+                valueType: {
+                    type: "string",
+                    ownership: "none",
+                },
+                listType: "ghashtable",
+                ownership: "none",
             },
-            value: formDataSet?.id ?? formDataSet,
+            value: formDataSet ? Array.from(formDataSet) : null,
         },
-    ], { type: "string" });
+    ], {
+        type: "string",
+        ownership: "full",
+    });
 };
 /**
  * Returns the major version number of the libsoup library.
@@ -463,38 +540,49 @@ export const getMinorVersion = () => {
  * case-insensitively).
  *
  * Note that this can't be used with lists that have qvalues.
- * @param header - An HTTP header suitable for parsing with
- * @param token - a token
  */
 export const headerContains = (header, token) => {
     return call("libsoup-3.0.so.0", "soup_header_contains", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: header,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: token,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
-/**
- * Frees `param_list`.
- * @param paramList - a #GHashTable returned from
- */
+/** Frees `param_list`. */
 export const headerFreeParamList = (paramList) => {
     call("libsoup-3.0.so.0", "soup_header_free_param_list", [
         {
             type: {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GHashTable",
-                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                getTypeFn: "g_hash_table_get_type",
+                type: "hashtable",
+                keyType: {
+                    type: "string",
+                    ownership: "none",
+                },
+                valueType: {
+                    type: "string",
+                    ownership: "none",
+                },
+                listType: "ghashtable",
+                ownership: "none",
             },
-            value: paramList?.id ?? paramList,
+            value: paramList ? Array.from(paramList) : null,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
 };
 /**
  * Appends something like `name=value` to `string`, taking care to quote `value`
@@ -507,32 +595,37 @@ export const headerFreeParamList = (paramList) => {
  * "filename" parameter.
  *
  * If `value` is %NULL, this will just append `name` to `string`.
- * @param string - a #GString being used to construct an HTTP header value
- * @param name - a parameter name
- * @param value - a parameter value, or %NULL
  */
 export const headerGStringAppendParam = (string, name, value) => {
     call("libsoup-3.0.so.0", "soup_header_g_string_append_param", [
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GString",
                 lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                 getTypeFn: "g_gstring_get_type",
             },
-            value: string?.id ?? string,
+            value: string.id,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: name,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: value,
             optional: true,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
 };
 /**
  * Appends something like `name="value"` to
@@ -540,49 +633,59 @@ export const headerGStringAppendParam = (string, name, value) => {
  *
  * If `value` is (non-ASCII) UTF-8, this will instead use RFC 5987
  * encoding, just like {@link header_g_string_append_param}.
- * @param string - a #GString being used to construct an HTTP header value
- * @param name - a parameter name
- * @param value - a parameter value
  */
 export const headerGStringAppendParamQuoted = (string, name, value) => {
     call("libsoup-3.0.so.0", "soup_header_g_string_append_param_quoted", [
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GString",
                 lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                 getTypeFn: "g_gstring_get_type",
             },
-            value: string?.id ?? string,
+            value: string.id,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: name,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: value,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
 };
 /**
  * Parses a header whose content is described by RFC2616 as `#something`.
  *
  * "something" does not itself contain commas, except as part of quoted-strings.
- * @param header - a header value
  */
 export const headerParseList = (header) => {
     return call("libsoup-3.0.so.0", "soup_header_parse_list", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: header,
         },
     ], {
         type: "array",
-        itemType: { type: "string" },
+        itemType: {
+            type: "string",
+            ownership: "full",
+        },
         listType: "gslist",
-        borrowed: true,
+        ownership: "full",
     });
 };
 /**
@@ -595,22 +698,30 @@ export const headerParseList = (header) => {
  * This also handles RFC5987 encoding (which in HTTP is mostly used
  * for giving UTF8-encoded filenames in the Content-Disposition
  * header).
- * @param header - a header value
  */
 export const headerParseParamList = (header) => {
-    const ptr = call("libsoup-3.0.so.0", "soup_header_parse_param_list", [
+    const tuples = call("libsoup-3.0.so.0", "soup_header_parse_param_list", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: header,
         },
     ], {
-        type: "boxed",
-        borrowed: true,
-        innerType: "GHashTable",
-        lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-        getTypeFn: "g_hash_table_get_type",
+        type: "hashtable",
+        keyType: {
+            type: "string",
+            ownership: "full",
+        },
+        valueType: {
+            type: "string",
+            ownership: "full",
+        },
+        listType: "ghashtable",
+        ownership: "full",
     });
-    return getNativeObject(ptr, GLib.HashTable);
+    return new Map(tuples);
 };
 /**
  * A strict version of {@link header_parse_param_list}
@@ -621,24 +732,32 @@ export const headerParseParamList = (header) => {
  * present. For header fields that might contain
  * RFC5987-encoded parameters, use
  * {@link header_parse_param_list} instead.
- * @param header - a header value
  */
 export const headerParseParamListStrict = (header) => {
-    const ptr = call("libsoup-3.0.so.0", "soup_header_parse_param_list_strict", [
+    const tuples = call("libsoup-3.0.so.0", "soup_header_parse_param_list_strict", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: header,
         },
     ], {
-        type: "boxed",
-        borrowed: true,
-        innerType: "GHashTable",
-        lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-        getTypeFn: "g_hash_table_get_type",
+        type: "hashtable",
+        keyType: {
+            type: "string",
+            ownership: "full",
+        },
+        valueType: {
+            type: "string",
+            ownership: "full",
+        },
+        listType: "ghashtable",
+        ownership: "full",
     });
-    if (ptr === null)
+    if (tuples === null)
         return null;
-    return getNativeObject(ptr, GLib.HashTable);
+    return new Map(tuples);
 };
 /**
  * Parses a header whose content is a list of items with optional
@@ -648,13 +767,14 @@ export const headerParseParamListStrict = (header) => {
  * If `unacceptable` is not %NULL, then on return, it will contain the
  * items with qvalue 0. Either way, those items will be removed from
  * the main list.
- * @param header - a header value
- * @param unacceptable - on
  */
 export const headerParseQualityList = (header, unacceptable) => {
     return call("libsoup-3.0.so.0", "soup_header_parse_quality_list", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: header,
         },
         {
@@ -662,8 +782,12 @@ export const headerParseQualityList = (header, unacceptable) => {
                 type: "ref",
                 innerType: {
                     type: "array",
-                    itemType: { type: "string" },
+                    itemType: {
+                        type: "string",
+                        ownership: "full",
+                    },
                     listType: "gslist",
+                    ownership: "full",
                 },
             },
             value: unacceptable,
@@ -671,9 +795,12 @@ export const headerParseQualityList = (header, unacceptable) => {
         },
     ], {
         type: "array",
-        itemType: { type: "string" },
+        itemType: {
+            type: "string",
+            ownership: "full",
+        },
         listType: "gslist",
-        borrowed: true,
+        ownership: "full",
     });
 };
 /**
@@ -686,22 +813,30 @@ export const headerParseQualityList = (header, unacceptable) => {
  * This also handles RFC5987 encoding (which in HTTP is mostly used
  * for giving UTF8-encoded filenames in the Content-Disposition
  * header).
- * @param header - a header value
  */
 export const headerParseSemiParamList = (header) => {
-    const ptr = call("libsoup-3.0.so.0", "soup_header_parse_semi_param_list", [
+    const tuples = call("libsoup-3.0.so.0", "soup_header_parse_semi_param_list", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: header,
         },
     ], {
-        type: "boxed",
-        borrowed: true,
-        innerType: "GHashTable",
-        lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-        getTypeFn: "g_hash_table_get_type",
+        type: "hashtable",
+        keyType: {
+            type: "string",
+            ownership: "full",
+        },
+        valueType: {
+            type: "string",
+            ownership: "full",
+        },
+        listType: "ghashtable",
+        ownership: "full",
     });
-    return getNativeObject(ptr, GLib.HashTable);
+    return new Map(tuples);
 };
 /**
  * A strict version of {@link header_parse_semi_param_list}
@@ -712,24 +847,32 @@ export const headerParseSemiParamList = (header) => {
  * present. For header fields that might contain
  * RFC5987-encoded parameters, use
  * {@link header_parse_semi_param_list} instead.
- * @param header - a header value
  */
 export const headerParseSemiParamListStrict = (header) => {
-    const ptr = call("libsoup-3.0.so.0", "soup_header_parse_semi_param_list_strict", [
+    const tuples = call("libsoup-3.0.so.0", "soup_header_parse_semi_param_list_strict", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: header,
         },
     ], {
-        type: "boxed",
-        borrowed: true,
-        innerType: "GHashTable",
-        lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-        getTypeFn: "g_hash_table_get_type",
+        type: "hashtable",
+        keyType: {
+            type: "string",
+            ownership: "full",
+        },
+        valueType: {
+            type: "string",
+            ownership: "full",
+        },
+        listType: "ghashtable",
+        ownership: "full",
     });
-    if (ptr === null)
+    if (tuples === null)
         return null;
-    return getNativeObject(ptr, GLib.HashTable);
+    return new Map(tuples);
 };
 /**
  * Parses the headers of an HTTP request or response in `str` and
@@ -739,120 +882,152 @@ export const headerParseSemiParamListStrict = (header) => {
  *
  * This is a low-level method; normally you would use
  * {@link headers_parse_request} or {@link headers_parse_response}.
- * @param str - the header string (including the Request-Line or Status-Line,
- * @param len - length of `str`
- * @param dest - #SoupMessageHeaders to store the header values in
  */
 export const headersParse = (str, len, dest) => {
     return call("libsoup-3.0.so.0", "soup_headers_parse", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: str,
         },
         {
-            type: { type: "int", size: 32, unsigned: false },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
             value: len,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "SoupMessageHeaders",
                 lib: "libsoup-3.0.so.0",
                 getTypeFn: "soup_message_headers_get_type",
             },
-            value: dest?.id ?? dest,
+            value: dest.id,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
 /**
  * Parses the headers of an HTTP request in `str` and stores the
  * results in `req_method`, `req_path`, `ver`, and `req_headers`.
  *
  * Beware that `req_headers` may be modified even on failure.
- * @param str - the headers (up to, but not including, the trailing blank line)
- * @param len - length of `str`
- * @param reqHeaders - #SoupMessageHeaders to store the header values in
- * @param reqMethod - if non-%NULL, will be filled in with the
- * @param reqPath - if non-%NULL, will be filled in with the
- * @param ver - if non-%NULL, will be filled in with the HTTP
  */
 export const headersParseRequest = (str, len, reqHeaders, reqMethod, reqPath, ver) => {
     return call("libsoup-3.0.so.0", "soup_headers_parse_request", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: str,
         },
         {
-            type: { type: "int", size: 32, unsigned: false },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
             value: len,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "SoupMessageHeaders",
                 lib: "libsoup-3.0.so.0",
                 getTypeFn: "soup_message_headers_get_type",
             },
-            value: reqHeaders?.id ?? reqHeaders,
+            value: reqHeaders.id,
         },
         {
-            type: { type: "ref", innerType: { type: "string" } },
+            type: {
+                type: "ref",
+                innerType: {
+                    type: "string",
+                    ownership: "full",
+                },
+            },
             value: reqMethod,
             optional: true,
         },
         {
-            type: { type: "ref", innerType: { type: "string" } },
+            type: {
+                type: "ref",
+                innerType: {
+                    type: "string",
+                    ownership: "full",
+                },
+            },
             value: reqPath,
             optional: true,
         },
         {
             type: {
                 type: "ref",
-                innerType: { type: "int", size: 32, unsigned: false },
+                innerType: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
             },
             value: ver,
             optional: true,
         },
-    ], { type: "int", size: 32, unsigned: true });
+    ], {
+        type: "int",
+        size: 32,
+        unsigned: true,
+    });
 };
 /**
  * Parses the headers of an HTTP response in `str` and stores the
  * results in `ver`, `status_code`, `reason_phrase`, and `headers`.
  *
  * Beware that `headers` may be modified even on failure.
- * @param str - the headers (up to, but not including, the trailing blank line)
- * @param len - length of `str`
- * @param headers - #SoupMessageHeaders to store the header values in
- * @param ver - if non-%NULL, will be filled in with the HTTP
- * @param statusCode - if non-%NULL, will be filled in with
- * @param reasonPhrase - if non-%NULL, will be filled in with
  */
 export const headersParseResponse = (str, len, headers, ver, statusCode, reasonPhrase) => {
     return call("libsoup-3.0.so.0", "soup_headers_parse_response", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: str,
         },
         {
-            type: { type: "int", size: 32, unsigned: false },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            },
             value: len,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "SoupMessageHeaders",
                 lib: "libsoup-3.0.so.0",
                 getTypeFn: "soup_message_headers_get_type",
             },
-            value: headers?.id ?? headers,
+            value: headers.id,
         },
         {
             type: {
                 type: "ref",
-                innerType: { type: "int", size: 32, unsigned: false },
+                innerType: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
             },
             value: ver,
             optional: true,
@@ -860,38 +1035,53 @@ export const headersParseResponse = (str, len, headers, ver, statusCode, reasonP
         {
             type: {
                 type: "ref",
-                innerType: { type: "int", size: 32, unsigned: true },
+                innerType: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
             },
             value: statusCode,
             optional: true,
         },
         {
-            type: { type: "ref", innerType: { type: "string" } },
+            type: {
+                type: "ref",
+                innerType: {
+                    type: "string",
+                    ownership: "full",
+                },
+            },
             value: reasonPhrase,
             optional: true,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
 /**
  * Parses the HTTP Status-Line string in `status_line` into `ver`,
  * `status_code`, and `reason_phrase`.
  *
  * `status_line` must be terminated by either "\0" or "\r\n".
- * @param statusLine - an HTTP Status-Line
- * @param ver - if non-%NULL, will be filled in with the HTTP
- * @param statusCode - if non-%NULL, will be filled in with
- * @param reasonPhrase - if non-%NULL, will be filled in with
  */
 export const headersParseStatusLine = (statusLine, ver, statusCode, reasonPhrase) => {
     return call("libsoup-3.0.so.0", "soup_headers_parse_status_line", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: statusLine,
         },
         {
             type: {
                 type: "ref",
-                innerType: { type: "int", size: 32, unsigned: false },
+                innerType: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
             },
             value: ver,
             optional: true,
@@ -899,43 +1089,54 @@ export const headersParseStatusLine = (statusLine, ver, statusCode, reasonPhrase
         {
             type: {
                 type: "ref",
-                innerType: { type: "int", size: 32, unsigned: true },
+                innerType: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
             },
             value: statusCode,
             optional: true,
         },
         {
-            type: { type: "ref", innerType: { type: "string" } },
+            type: {
+                type: "ref",
+                innerType: {
+                    type: "string",
+                    ownership: "full",
+                },
+            },
             value: reasonPhrase,
             optional: true,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
-/**
- * Initializes `iter` for iterating `hdrs`.
- * @param iter - a pointer to a %SoupMessageHeadersIter
- * @param hdrs - a %SoupMessageHeaders
- */
+/** Initializes `iter` for iterating `hdrs`. */
 export const messageHeadersIterInit = (iter, hdrs) => {
     call("libsoup-3.0.so.0", "soup_message_headers_iter_init", [
         {
             type: {
-                type: "ref",
-                innerType: { type: "int", size: 64, unsigned: true },
+                type: "struct",
+                ownership: "none",
+                innerType: "MessageHeadersIter",
             },
-            value: iter,
+            value: iter.id,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "SoupMessageHeaders",
                 lib: "libsoup-3.0.so.0",
                 getTypeFn: "soup_message_headers_get_type",
             },
-            value: hdrs?.id ?? hdrs,
+            value: hdrs.id,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
 };
 /**
  * Yields the next name/value pair in the {@link MessageHeaders} being
@@ -944,32 +1145,45 @@ export const messageHeadersIterInit = (iter, hdrs) => {
  * If `iter` has already yielded the last header, then
  * {@link MessageHeadersIter.next} will return %FALSE and `name` and `value`
  * will be unchanged.
- * @param iter - a %SoupMessageHeadersIter
- * @param name - pointer to a variable to return
- * @param value - pointer to a variable to return
  */
 export const messageHeadersIterNext = (iter, name, value) => {
     return call("libsoup-3.0.so.0", "soup_message_headers_iter_next", [
         {
             type: {
                 type: "ref",
-                innerType: { type: "int", size: 64, unsigned: true },
+                innerType: {
+                    type: "struct",
+                    ownership: "none",
+                    innerType: "MessageHeadersIter",
+                },
             },
             value: iter,
         },
         {
-            type: { type: "ref", innerType: { type: "string" } },
+            type: {
+                type: "ref",
+                innerType: {
+                    type: "string",
+                    ownership: "none",
+                },
+            },
             value: name,
         },
         {
-            type: { type: "ref", innerType: { type: "string" } },
+            type: {
+                type: "ref",
+                innerType: {
+                    type: "string",
+                    ownership: "none",
+                },
+            },
             value: value,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
-/**
- * Registers error quark for SoupSession if needed.
- */
+/** Registers error quark for SoupSession if needed. */
 export const sessionErrorQuark = () => {
     return call("libsoup-3.0.so.0", "soup_session_error_quark", [], {
         type: "int",
@@ -989,15 +1203,21 @@ export const sessionErrorQuark = () => {
  * anyway, and so they should never be presented to the user directly.
  * Instead, you should create you own error messages based on the
  * status code, and on what you were trying to do.
- * @param statusCode - an HTTP status code
  */
 export const statusGetPhrase = (statusCode) => {
     return call("libsoup-3.0.so.0", "soup_status_get_phrase", [
         {
-            type: { type: "int", size: 32, unsigned: true },
+            type: {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            },
             value: statusCode,
         },
-    ], { type: "string", borrowed: true });
+    ], {
+        type: "string",
+        ownership: "none",
+    });
 };
 /**
  * Looks whether the `domain` passed as argument is a public domain
@@ -1006,19 +1226,21 @@ export const statusGetPhrase = (statusCode) => {
  * Prior to libsoup 2.46, this function required that `domain` be in
  * UTF-8 if it was an IDN. From 2.46 on, the name can be in either
  * UTF-8 or ASCII format.
- * @param domain - a domain name
  */
 export const tldDomainIsPublicSuffix = (domain) => {
     return call("libsoup-3.0.so.0", "soup_tld_domain_is_public_suffix", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: domain,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
-/**
- * Registers error quark for soup_tld_get_base_domain() if needed.
- */
+/** Registers error quark for soup_tld_get_base_domain() if needed. */
 export const tldErrorQuark = () => {
     return call("libsoup-3.0.so.0", "soup_tld_error_quark", [], {
         type: "int",
@@ -1041,13 +1263,15 @@ export const tldErrorQuark = () => {
  * UTF-8 if it was an IDN. From 2.46 on, the name can be in either
  * UTF-8 or ASCII format (and the return value will be in the same
  * format).
- * @param hostname - a hostname
  */
 export const tldGetBaseDomain = (hostname) => {
     const error = { value: null };
     const result = call("libsoup-3.0.so.0", "soup_tld_get_base_domain", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: hostname,
         },
         {
@@ -1055,71 +1279,78 @@ export const tldGetBaseDomain = (hostname) => {
                 type: "ref",
                 innerType: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GError",
-                    lib: "libglib-2.0.so.0",
+                    lib: "libgobject-2.0.so.0",
                 },
             },
             value: error,
         },
-    ], { type: "string", borrowed: true });
+    ], {
+        type: "string",
+        ownership: "none",
+    });
     if (error.value !== null) {
-        throw new NativeError(error.value);
+        throw new NativeError(getNativeObject(error.value, GLib.GError));
     }
     return result;
 };
-/**
- * Decodes the given data URI and returns its contents and `content_type`.
- * @param uri - a data URI, in string form
- * @param contentType - location to store content type
- */
+/** Decodes the given data URI and returns its contents and `content_type`. */
 export const uriDecodeDataUri = (uri, contentType) => {
     const ptr = call("libsoup-3.0.so.0", "soup_uri_decode_data_uri", [
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: uri,
         },
         {
-            type: { type: "ref", innerType: { type: "string" } },
+            type: {
+                type: "ref",
+                innerType: {
+                    type: "string",
+                    ownership: "full",
+                },
+            },
             value: contentType,
             optional: true,
         },
     ], {
         type: "boxed",
-        borrowed: true,
+        ownership: "full",
         innerType: "GBytes",
         lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
         getTypeFn: "g_bytes_get_type",
     });
     return getNativeObject(ptr, GLib.Bytes);
 };
-/**
- * Tests whether or not `uri1` and `uri2` are equal in all parts.
- * @param uri1 - a #GUri
- * @param uri2 - another #GUri
- */
+/** Tests whether or not `uri1` and `uri2` are equal in all parts. */
 export const uriEqual = (uri1, uri2) => {
     return call("libsoup-3.0.so.0", "soup_uri_equal", [
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GUri",
                 lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                 getTypeFn: "g_uri_get_type",
             },
-            value: uri1?.id ?? uri1,
+            value: uri1.id,
         },
         {
             type: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "none",
                 innerType: "GUri",
                 lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
                 getTypeFn: "g_uri_get_type",
             },
-            value: uri2?.id ?? uri2,
+            value: uri2.id,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };
 /**
  * Adds the necessary headers to `msg` to request a WebSocket
@@ -1131,39 +1362,54 @@ export const uriEqual = (uri1, uri2) => {
  * This is a low-level function; if you use
  * {@link Session.websocket_connect_async} to create a WebSocket connection, it
  * will call this for you.
- * @param msg - a #SoupMessage
- * @param origin - the "Origin" header to set
- * @param protocols - list of
- * @param supportedExtensions - list
  */
 export const websocketClientPrepareHandshake = (msg, origin, protocols, supportedExtensions) => {
     call("libsoup-3.0.so.0", "soup_websocket_client_prepare_handshake", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: msg?.id ?? msg,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: msg.id,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: origin,
             optional: true,
         },
         {
-            type: { type: "array", itemType: { type: "string", borrowed: true } },
+            type: {
+                type: "array",
+                itemType: {
+                    type: "string",
+                    ownership: "none",
+                },
+                listType: "array",
+                ownership: "none",
+            },
             value: protocols,
             optional: true,
         },
         {
             type: {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GPtrArray",
-                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                getTypeFn: "g_ptr_array_get_type",
+                type: "array",
+                itemType: {
+                    type: "struct",
+                    ownership: "none",
+                    innerType: "TypeClass",
+                },
+                listType: "gptrarray",
+                ownership: "none",
             },
-            value: supportedExtensions?.id ?? supportedExtensions,
+            value: supportedExtensions,
             optional: true,
         },
-    ], { type: "undefined" });
+    ], {
+        type: "undefined",
+    });
 };
 /**
  * Looks at the response status code and headers in `msg` and
@@ -1177,26 +1423,29 @@ export const websocketClientPrepareHandshake = (msg, origin, protocols, supporte
  * This is a low-level function; if you use
  * {@link Session.websocket_connect_async} to create a WebSocket
  * connection, it will call this for you.
- * @param msg - #SoupMessage containing both client and server sides of a
- * @param supportedExtensions - list
- * @param acceptedExtensions - a
  */
 export const websocketClientVerifyHandshake = (msg, supportedExtensions, acceptedExtensions) => {
     const error = { value: null };
     const result = call("libsoup-3.0.so.0", "soup_websocket_client_verify_handshake", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: msg?.id ?? msg,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: msg.id,
         },
         {
             type: {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GPtrArray",
-                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                getTypeFn: "g_ptr_array_get_type",
+                type: "array",
+                itemType: {
+                    type: "struct",
+                    ownership: "none",
+                    innerType: "TypeClass",
+                },
+                listType: "gptrarray",
+                ownership: "none",
             },
-            value: supportedExtensions?.id ?? supportedExtensions,
+            value: supportedExtensions,
             optional: true,
         },
         {
@@ -1204,8 +1453,12 @@ export const websocketClientVerifyHandshake = (msg, supportedExtensions, accepte
                 type: "ref",
                 innerType: {
                     type: "array",
-                    itemType: { type: "gobject" },
+                    itemType: {
+                        type: "gobject",
+                        ownership: "full",
+                    },
                     listType: "glist",
+                    ownership: "full",
                 },
             },
             value: acceptedExtensions,
@@ -1216,21 +1469,22 @@ export const websocketClientVerifyHandshake = (msg, supportedExtensions, accepte
                 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;
 };
-/**
- * Registers error quark for SoupWebsocket if needed.
- */
+/** Registers error quark for SoupWebsocket if needed. */
 export const websocketErrorQuark = () => {
     return call("libsoup-3.0.so.0", "soup_websocket_error_quark", [], {
         type: "int",
@@ -1256,37 +1510,50 @@ export const websocketErrorQuark = () => {
  * be useful if you need to perform more complicated validation; eg,
  * accepting multiple different Origins, or handling different protocols
  * depending on the path.
- * @param msg - #SoupServerMessage containing the client side of a WebSocket handshake
- * @param origin - expected Origin header
- * @param protocols - allowed WebSocket
- * @param supportedExtensions - list
  */
 export const websocketServerCheckHandshake = (msg, origin, protocols, supportedExtensions) => {
     const error = { value: null };
     const result = call("libsoup-3.0.so.0", "soup_websocket_server_check_handshake", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: msg?.id ?? msg,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: msg.id,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: origin,
             optional: true,
         },
         {
-            type: { type: "array", itemType: { type: "string", borrowed: true } },
+            type: {
+                type: "array",
+                itemType: {
+                    type: "string",
+                    ownership: "none",
+                },
+                listType: "array",
+                ownership: "none",
+            },
             value: protocols,
             optional: true,
         },
         {
             type: {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GPtrArray",
-                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                getTypeFn: "g_ptr_array_get_type",
+                type: "array",
+                itemType: {
+                    type: "struct",
+                    ownership: "none",
+                    innerType: "TypeClass",
+                },
+                listType: "gptrarray",
+                ownership: "none",
             },
-            value: supportedExtensions?.id ?? supportedExtensions,
+            value: supportedExtensions,
             optional: true,
         },
         {
@@ -1294,15 +1561,18 @@ export const websocketServerCheckHandshake = (msg, origin, protocols, supportedE
                 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;
 };
@@ -1322,37 +1592,49 @@ export const websocketServerCheckHandshake = (msg, origin, protocols, supportedE
  * This is a low-level function; if you use
  * {@link Server.add_websocket_handler} to handle accepting WebSocket
  * connections, it will call this for you.
- * @param msg - #SoupServerMessage containing the client side of a WebSocket handshake
- * @param expectedOrigin - expected Origin header
- * @param protocols - allowed WebSocket
- * @param supportedExtensions - list
- * @param acceptedExtensions - a
  */
 export const websocketServerProcessHandshake = (msg, expectedOrigin, protocols, supportedExtensions, acceptedExtensions) => {
     return call("libsoup-3.0.so.0", "soup_websocket_server_process_handshake", [
         {
-            type: { type: "gobject", borrowed: true },
-            value: msg?.id ?? msg,
+            type: {
+                type: "gobject",
+                ownership: "none",
+            },
+            value: msg.id,
         },
         {
-            type: { type: "string", borrowed: true },
+            type: {
+                type: "string",
+                ownership: "none",
+            },
             value: expectedOrigin,
             optional: true,
         },
         {
-            type: { type: "array", itemType: { type: "string", borrowed: true } },
+            type: {
+                type: "array",
+                itemType: {
+                    type: "string",
+                    ownership: "none",
+                },
+                listType: "array",
+                ownership: "none",
+            },
             value: protocols,
             optional: true,
         },
         {
             type: {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GPtrArray",
-                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                getTypeFn: "g_ptr_array_get_type",
+                type: "array",
+                itemType: {
+                    type: "struct",
+                    ownership: "none",
+                    innerType: "TypeClass",
+                },
+                listType: "gptrarray",
+                ownership: "none",
             },
-            value: supportedExtensions?.id ?? supportedExtensions,
+            value: supportedExtensions,
             optional: true,
         },
         {
@@ -1360,12 +1642,18 @@ export const websocketServerProcessHandshake = (msg, expectedOrigin, protocols,
                 type: "ref",
                 innerType: {
                     type: "array",
-                    itemType: { type: "gobject" },
+                    itemType: {
+                        type: "gobject",
+                        ownership: "full",
+                    },
                     listType: "glist",
+                    ownership: "full",
                 },
             },
             value: acceptedExtensions,
             optional: true,
         },
-    ], { type: "boolean" });
+    ], {
+        type: "boolean",
+    });
 };