@gtkx/ffi 0.1.47 → 0.1.48

package/dist/generated/gio/proxy-address-enumerator.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { SocketAddressEnumerator } from "./socket-address-enumerator.js";
 /**
  * `GProxyAddressEnumerator` is a wrapper around
@@ -14,4 +15,6 @@ import { SocketAddressEnumerator } from "./socket-address-enumerator.js";
 export declare class ProxyAddressEnumerator extends SocketAddressEnumerator {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    connect(signal: "notify", handler: (self: ProxyAddressEnumerator, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/proxy-address-enumerator.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { getObject } from "@gtkx/ffi";
 import { SocketAddressEnumerator } from "./socket-address-enumerator.js";
 /**
  * `GProxyAddressEnumerator` is a wrapper around
@@ -23,4 +24,22 @@ export class ProxyAddressEnumerator extends SocketAddressEnumerator {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], ProxyAddressEnumerator);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgio-2.0.so.0", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/proxy-address.d.ts

@@ -1,4 +1,5 @@
 import { InetAddress } from "./inet-address.js";
+import * as GObject from "../gobject/index.js";
 import { InetSocketAddress } from "./inet-socket-address.js";
 /** A [class@Gio.InetSocketAddress] representing a connection via a proxy server. */
 export declare class ProxyAddress extends InetSocketAddress {
@@ -53,4 +54,6 @@ export declare class ProxyAddress extends InetSocketAddress {
      * Gets @proxy's username.
      */
     getUsername(): string | null;
+    connect(signal: "notify", handler: (self: ProxyAddress, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/proxy-address.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { getObject } from "@gtkx/ffi";
 import { InetSocketAddress } from "./inet-socket-address.js";
 /** A [class@Gio.InetSocketAddress] representing a connection via a proxy server. */
 export class ProxyAddress extends InetSocketAddress {
@@ -122,4 +123,22 @@ export class ProxyAddress extends InetSocketAddress {
             },
         ], { type: "string", borrowed: true });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], ProxyAddress);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgio-2.0.so.0", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/simple-iostream.d.ts

@@ -1,5 +1,6 @@
 import { InputStream } from "./input-stream.js";
 import { OutputStream } from "./output-stream.js";
+import * as GObject from "../gobject/index.js";
 import { IOStream } from "./iostream.js";
 /**
  * `GSimpleIOStream` creates a [class@Gio.IOStream] from an arbitrary
@@ -23,4 +24,6 @@ export declare class SimpleIOStream extends IOStream {
     constructor(inputStream: InputStream, outputStream: OutputStream);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    connect(signal: "notify", handler: (self: SimpleIOStream, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/simple-iostream.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { getObject } from "@gtkx/ffi";
 import { IOStream } from "./iostream.js";
 /**
  * `GSimpleIOStream` creates a [class@Gio.IOStream] from an arbitrary
@@ -29,4 +30,22 @@ export class SimpleIOStream extends IOStream {
             },
         ], { type: "gobject", borrowed: false });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], SimpleIOStream);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgio-2.0.so.0", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/simple-permission.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { Permission } from "./permission.js";
 /**
  * `GSimplePermission` is a trivial implementation of [class@Gio.Permission]
@@ -16,4 +17,6 @@ export declare class SimplePermission extends Permission {
     constructor(allowed: boolean);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    connect(signal: "notify", handler: (self: SimplePermission, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/simple-permission.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { getObject } from "@gtkx/ffi";
 import { Permission } from "./permission.js";
 /**
  * `GSimplePermission` is a trivial implementation of [class@Gio.Permission]
@@ -21,4 +22,22 @@ export class SimplePermission extends Permission {
             },
         ], { type: "gobject", borrowed: false });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], SimplePermission);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgio-2.0.so.0", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/socket-connection.d.ts

@@ -3,6 +3,7 @@ import { AsyncResult } from "./async-result.js";
 import { Cancellable } from "./cancellable.js";
 import { Socket } from "./socket.js";
 import { SocketAddress } from "./socket-address.js";
+import * as GObject from "../gobject/index.js";
 import { IOStream } from "./iostream.js";
 /**
  * `GSocketConnection` is a [class@Gio.IOStream] for a connected socket. They
@@ -100,4 +101,6 @@ export declare class SocketConnection extends IOStream {
      * g_socket_is_connected() on @connection's underlying #GSocket.
      */
     isConnected(): boolean;
+    on(signal: "notify", handler: (self: SocketConnection, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    on(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/socket-connection.js

@@ -291,4 +291,22 @@ export class SocketConnection extends IOStream {
             },
         ], { type: "boolean" });
     }
+    on(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], SocketConnection);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgio-2.0.so.0", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/socket-service.d.ts

@@ -1,3 +1,5 @@
+import { SocketListenerEvent } from "./enums.js";
+import { Socket } from "./socket.js";
 import { SocketConnection } from "./socket-connection.js";
 import * as GObject from "../gobject/index.js";
 import { SocketListener } from "./socket-listener.js";
@@ -49,6 +51,7 @@ export declare class SocketService extends SocketListener {
      */
     stop(): void;
     connect(signal: "incoming", handler: (self: SocketService, connection: SocketConnection, sourceObject: GObject.GObject) => boolean, after?: boolean): number;
+    connect(signal: "event", handler: (self: SocketService, event: SocketListenerEvent, socket: Socket) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: SocketService, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/socket-service.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Socket } from "./socket.js";
 import { SocketConnection } from "./socket-connection.js";
 import * as GObject from "../gobject/index.js";
 import { SocketListener } from "./socket-listener.js";
@@ -45,6 +46,13 @@ const SIGNAL_META = {
         ],
         returnType: { type: "boolean" },
     },
+    event: {
+        params: [
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "gobject", borrowed: true }, getCls: () => Socket },
+        ],
+        returnType: { type: "undefined" },
+    },
 };
 export class SocketService extends SocketListener {
     /**

package/dist/generated/gio/tcp-connection.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { SocketConnection } from "./socket-connection.js";
 /**
  * This is the subclass of [class@Gio.SocketConnection] that is created
@@ -24,4 +25,6 @@ export declare class TcpConnection extends SocketConnection {
      * @param gracefulDisconnect - Whether to do graceful disconnects or not
      */
     setGracefulDisconnect(gracefulDisconnect: boolean): void;
+    connect(signal: "notify", handler: (self: TcpConnection, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/tcp-connection.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { getObject } from "@gtkx/ffi";
 import { SocketConnection } from "./socket-connection.js";
 /**
  * This is the subclass of [class@Gio.SocketConnection] that is created
@@ -55,4 +56,22 @@ export class TcpConnection extends SocketConnection {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], TcpConnection);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgio-2.0.so.0", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/tcp-wrapper-connection.d.ts

@@ -1,5 +1,6 @@
 import { IOStream } from "./iostream.js";
 import { Socket } from "./socket.js";
+import * as GObject from "../gobject/index.js";
 import { TcpConnection } from "./tcp-connection.js";
 /**
  * A `GTcpWrapperConnection` can be used to wrap a [class@Gio.IOStream] that is
@@ -22,4 +23,6 @@ export declare class TcpWrapperConnection extends TcpConnection {
      * Gets @conn's base #GIOStream
      */
     getBaseIoStream(): IOStream;
+    connect(signal: "notify", handler: (self: TcpWrapperConnection, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/tcp-wrapper-connection.js

@@ -39,4 +39,22 @@ export class TcpWrapperConnection extends TcpConnection {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, IOStream);
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], TcpWrapperConnection);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgio-2.0.so.0", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/threaded-resolver.d.ts

@@ -1,12 +1,9 @@
 import * as GObject from "../gobject/index.js";
 import { Resolver } from "./resolver.js";
-/**
- * #GThreadedResolver is an implementation of #GResolver which calls the libc
- * lookup functions in threads to allow them to run asynchronously.
- */
 export declare class ThreadedResolver extends Resolver {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    connect(signal: "reload", handler: (self: ThreadedResolver) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: ThreadedResolver, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/threaded-resolver.js

@@ -5,6 +5,9 @@ import { Resolver } from "./resolver.js";
  * #GThreadedResolver is an implementation of #GResolver which calls the libc
  * lookup functions in threads to allow them to run asynchronously.
  */
+const SIGNAL_META = {
+    reload: { params: [], returnType: { type: "undefined" } },
+};
 export class ThreadedResolver extends Resolver {
     constructor(...args) {
         super(...args);
@@ -21,12 +24,24 @@ export class ThreadedResolver extends Resolver {
         ], { type: "gobject", borrowed: true });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getObject(args[0], ThreadedResolver);
-            return handler(self, ...args.slice(1));
+            const signalArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...signalArgs);
+            const wrapped = meta.params.map((m, i) => {
+                if (m.getCls && signalArgs[i] != null) {
+                    return getObject(signalArgs[i], m.getCls());
+                }
+                return signalArgs[i];
+            });
+            return handler(self, ...wrapped);
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.ptr },

package/dist/generated/gio/threaded-socket-service.d.ts

@@ -1,3 +1,5 @@
+import { SocketListenerEvent } from "./enums.js";
+import { Socket } from "./socket.js";
 import { SocketConnection } from "./socket-connection.js";
 import * as GObject from "../gobject/index.js";
 import { SocketService } from "./socket-service.js";
@@ -12,6 +14,7 @@ export declare class ThreadedSocketService extends SocketService {
     protected createPtr(args: unknown[]): unknown;
     connect(signal: "run", handler: (self: ThreadedSocketService, connection: SocketConnection, sourceObject: GObject.GObject) => boolean, after?: boolean): number;
     connect(signal: "incoming", handler: (self: ThreadedSocketService, connection: SocketConnection, sourceObject: GObject.GObject) => boolean, after?: boolean): number;
+    connect(signal: "event", handler: (self: ThreadedSocketService, event: SocketListenerEvent, socket: Socket) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: ThreadedSocketService, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/threaded-socket-service.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Socket } from "./socket.js";
 import { SocketConnection } from "./socket-connection.js";
 import * as GObject from "../gobject/index.js";
 import { SocketService } from "./socket-service.js";
@@ -48,6 +49,13 @@ const SIGNAL_META = {
         ],
         returnType: { type: "boolean" },
     },
+    event: {
+        params: [
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "gobject", borrowed: true }, getCls: () => Socket },
+        ],
+        returnType: { type: "undefined" },
+    },
 };
 export class ThreadedSocketService extends SocketService {
     constructor(...args) {

package/dist/generated/gio/unix-connection.d.ts

@@ -1,6 +1,7 @@
 import { AsyncResult } from "./async-result.js";
 import { Cancellable } from "./cancellable.js";
 import { Credentials } from "./credentials.js";
+import * as GObject from "../gobject/index.js";
 import { SocketConnection } from "./socket-connection.js";
 /**
  * This is the subclass of [class@Gio.SocketConnection] that is created
@@ -125,4 +126,6 @@ export declare class UnixConnection extends SocketConnection {
      * @param cancellable - optional #GCancellable object, %NULL to ignore.
      */
     sendFd(fd: number, cancellable?: Cancellable | null): boolean;
+    connect(signal: "notify", handler: (self: UnixConnection, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/unix-connection.js

@@ -351,4 +351,22 @@ export class UnixConnection extends SocketConnection {
         }
         return result;
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], UnixConnection);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgio-2.0.so.0", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/unix-credentials-message.d.ts

@@ -1,4 +1,5 @@
 import { Credentials } from "./credentials.js";
+import * as GObject from "../gobject/index.js";
 import { SocketControlMessage } from "./socket-control-message.js";
 /**
  * This [class@Gio.SocketControlMessage] contains a [class@Gio.Credentials]
@@ -40,4 +41,6 @@ export declare class UnixCredentialsMessage extends SocketControlMessage {
      * Gets the credentials stored in @message.
      */
     getCredentials(): Credentials;
+    connect(signal: "notify", handler: (self: UnixCredentialsMessage, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/unix-credentials-message.js

@@ -67,4 +67,22 @@ export class UnixCredentialsMessage extends SocketControlMessage {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Credentials);
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], UnixCredentialsMessage);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgio-2.0.so.0", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/unix-socket-address.d.ts

@@ -1,4 +1,5 @@
 import { UnixSocketAddressType } from "./enums.js";
+import * as GObject from "../gobject/index.js";
 import { SocketAddress } from "./socket-address.js";
 /**
  * Support for UNIX-domain (also known as local) sockets, corresponding to
@@ -101,4 +102,6 @@ export declare class UnixSocketAddress extends SocketAddress {
      * For details, see g_unix_socket_address_get_path().
      */
     getPathLen(): number;
+    connect(signal: "notify", handler: (self: UnixSocketAddress, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/unix-socket-address.js

@@ -168,4 +168,22 @@ export class UnixSocketAddress extends SocketAddress {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], UnixSocketAddress);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgio-2.0.so.0", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/glib/byte-array.d.ts

@@ -130,7 +130,7 @@ export declare class ByteArray {
      * @param compareFunc - the comparison function
      * @param userData - the data to pass to @compare_func
      */
-    static sortWithData(array: ByteArray, compareFunc: (...args: unknown[]) => unknown, userData?: number | null): void;
+    static sortWithData(array: ByteArray, compareFunc: (a: unknown, b: unknown) => number): void;
     /**
      * Frees the data in the array and resets the size to zero, while
      * the underlying array is preserved for use elsewhere and returned

package/dist/generated/glib/byte-array.js

@@ -391,7 +391,7 @@ export class ByteArray {
      * @param compareFunc - the comparison function
      * @param userData - the data to pass to @compare_func
      */
-    static sortWithData(array, compareFunc, userData) {
+    static sortWithData(array, compareFunc) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_sort_with_data", [
             {
                 type: {
@@ -403,14 +403,16 @@ export class ByteArray {
                 value: array?.ptr ?? array,
             },
             {
-                type: { type: "callback" },
+                type: {
+                    type: "callback",
+                    trampoline: "compareDataFunc",
+                    argTypes: [
+                        { type: "gobject", borrowed: true },
+                        { type: "gobject", borrowed: true },
+                    ],
+                },
                 value: compareFunc,
             },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
         ], { type: "undefined" });
     }
     /**

package/dist/generated/glib/functions.d.ts

@@ -1122,7 +1122,7 @@ export declare const byteArraySort: (array: ByteArray, compareFunc: (...args: un
  * @param compareFunc - the comparison function
  * @param userData - the data to pass to @compare_func
  */
-export declare const byteArraySortWithData: (array: ByteArray, compareFunc: (...args: unknown[]) => unknown, userData?: number | null) => void;
+export declare const byteArraySortWithData: (array: ByteArray, compareFunc: (a: unknown, b: unknown) => number) => void;
 /**
  * Frees the data in the array and resets the size to zero, while
  * the underlying array is preserved for use elsewhere and returned
@@ -4429,7 +4429,7 @@ export declare const propagateError: (src: GError, dest?: Ref<GError> | null) =>
  * @param compareFunc - function to compare elements
  * @param userData - data to pass to @compare_func
  */
-export declare const qsortWithData: (pbase: number, totalElems: number, size: number, compareFunc: (...args: unknown[]) => unknown, userData?: number | null) => void;
+export declare const qsortWithData: (pbase: number, totalElems: number, size: number, compareFunc: (a: unknown, b: unknown) => number) => void;
 /**
  * Gets the #GQuark identifying the given (static) string. If the
  * string does not currently have an associated #GQuark, a new #GQuark
@@ -4898,7 +4898,7 @@ export declare const sequenceSet: (iter: number, data?: number | null) => void;
  * @param cmpFunc - the function used to compare items in the sequence
  * @param cmpData - user data passed to @cmp_func.
  */
-export declare const sequenceSortChanged: (iter: number, cmpFunc: (...args: unknown[]) => unknown, cmpData?: number | null) => void;
+export declare const sequenceSortChanged: (iter: number, cmpFunc: (a: unknown, b: unknown) => number) => void;
 /**
  * Like g_sequence_sort_changed(), but uses
  * a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as