@gtkx/ffi 0.1.47 → 0.1.48

package/dist/generated/gio/dbus-menu-model.js

@@ -6,6 +6,16 @@ import { MenuModel } from "./menu-model.js";
  * used as a proxy for a menu model that is exported over D-Bus with
  * [method@Gio.DBusConnection.export_menu_model].
  */
+const SIGNAL_META = {
+    "items-changed": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "int", size: 32, unsigned: false } },
+        ],
+        returnType: { type: "undefined" },
+    },
+};
 export class DBusMenuModel extends MenuModel {
     constructor(...args) {
         super(...args);
@@ -53,12 +63,24 @@ export class DBusMenuModel extends MenuModel {
         return getObject(ptr, DBusMenuModel);
     }
     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], DBusMenuModel);
-            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/file-input-stream.d.ts

@@ -2,6 +2,7 @@ import { AsyncResult } from "./async-result.js";
 import { Cancellable } from "./cancellable.js";
 import { FileInfo } from "./file-info.js";
 import * as GLib from "../glib/index.js";
+import * as GObject from "../gobject/index.js";
 import { InputStream } from "./input-stream.js";
 /**
  * `GFileInputStream` provides input streams that take their
@@ -98,4 +99,6 @@ export declare class FileInputStream extends InputStream {
      * @param cancellable - optional #GCancellable object, %NULL to ignore.
      */
     truncate(offset: number, cancellable?: Cancellable | null): boolean;
+    connect(signal: "notify", handler: (self: FileInputStream, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/file-input-stream.js

@@ -287,4 +287,22 @@ export class FileInputStream extends InputStream {
         }
         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], FileInputStream);
+            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/file-iostream.d.ts

@@ -2,6 +2,7 @@ import { AsyncResult } from "./async-result.js";
 import { Cancellable } from "./cancellable.js";
 import { FileInfo } from "./file-info.js";
 import * as GLib from "../glib/index.js";
+import * as GObject from "../gobject/index.js";
 import { IOStream } from "./iostream.js";
 /**
  * `GFileIOStream` provides I/O streams that both read and write to the same
@@ -122,4 +123,6 @@ export declare class FileIOStream extends IOStream {
      * @param cancellable - optional #GCancellable object, %NULL to ignore.
      */
     truncate(offset: number, cancellable?: Cancellable | null): boolean;
+    connect(signal: "notify", handler: (self: FileIOStream, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -318,4 +318,22 @@ export class FileIOStream extends IOStream {
         }
         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], FileIOStream);
+            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/file-output-stream.d.ts

@@ -2,6 +2,7 @@ import { AsyncResult } from "./async-result.js";
 import { Cancellable } from "./cancellable.js";
 import { FileInfo } from "./file-info.js";
 import * as GLib from "../glib/index.js";
+import * as GObject from "../gobject/index.js";
 import { OutputStream } from "./output-stream.js";
 /**
  * `GFileOutputStream` provides output streams that write their
@@ -117,4 +118,6 @@ export declare class FileOutputStream extends OutputStream {
      * @param cancellable - optional #GCancellable object, %NULL to ignore.
      */
     truncate(offset: number, cancellable?: Cancellable | null): boolean;
+    connect(signal: "notify", handler: (self: FileOutputStream, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/file-output-stream.js

@@ -313,4 +313,22 @@ export class FileOutputStream extends OutputStream {
         }
         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], FileOutputStream);
+            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/filter-input-stream.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { InputStream } from "./input-stream.js";
 /**
  * Base class for input stream implementations that perform some
@@ -22,4 +23,6 @@ export declare class FilterInputStream extends InputStream {
      * @param closeBase - %TRUE to close the base stream.
      */
     setCloseBaseStream(closeBase: boolean): void;
+    connect(signal: "notify", handler: (self: FilterInputStream, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/filter-input-stream.js

@@ -62,4 +62,22 @@ export class FilterInputStream extends InputStream {
             },
         ], { 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], FilterInputStream);
+            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/filter-output-stream.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { OutputStream } from "./output-stream.js";
 /**
  * Base class for output stream implementations that perform some
@@ -22,4 +23,6 @@ export declare class FilterOutputStream extends OutputStream {
      * @param closeBase - `TRUE` to close the base stream.
      */
     setCloseBaseStream(closeBase: boolean): void;
+    connect(signal: "notify", handler: (self: FilterOutputStream, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/filter-output-stream.js

@@ -58,4 +58,22 @@ export class FilterOutputStream extends OutputStream {
             },
         ], { 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], FilterOutputStream);
+            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/inet-socket-address.d.ts

@@ -1,4 +1,5 @@
 import { InetAddress } from "./inet-address.js";
+import * as GObject from "../gobject/index.js";
 import { SocketAddress } from "./socket-address.js";
 /**
  * An IPv4 or IPv6 socket address. That is, the combination of a
@@ -48,4 +49,6 @@ export declare class InetSocketAddress extends SocketAddress {
      * If not overridden this value will be inherited from [property@Gio.InetSocketAddress:address].
      */
     getScopeId(): number;
+    connect(signal: "notify", handler: (self: InetSocketAddress, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -99,4 +99,22 @@ export class InetSocketAddress extends SocketAddress {
             },
         ], { type: "int", size: 32, 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], InetSocketAddress);
+            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/list-store.d.ts

@@ -88,7 +88,7 @@ export declare class ListStore extends GObject.GObject {
      * @param compareFunc - pairwise comparison function for sorting
      * @param userData - user data for @compare_func
      */
-    insertSorted(item: GObject.GObject, compareFunc: (...args: unknown[]) => unknown, userData?: number | null): number;
+    insertSorted(item: GObject.GObject, compareFunc: (a: unknown, b: unknown) => number): number;
     /**
      * Removes the item from `store` that is at @position. `position` must be
      * smaller than the current length of the list.
@@ -107,7 +107,7 @@ export declare class ListStore extends GObject.GObject {
      * @param compareFunc - pairwise comparison function for sorting
      * @param userData - user data for @compare_func
      */
-    sort(compareFunc: (...args: unknown[]) => unknown, userData?: number | null): void;
+    sort(compareFunc: (a: unknown, b: unknown) => number): void;
     /**
      * Changes `store` by removing `n_removals` items and adding `n_additions` items to it. `additions` must contain `n_additions` items of type
      * #GListStore:item-type.  %NULL is not permitted.

package/dist/generated/gio/list-store.js

@@ -192,7 +192,7 @@ export class ListStore extends GObject.GObject {
      * @param compareFunc - pairwise comparison function for sorting
      * @param userData - user data for @compare_func
      */
-    insertSorted(item, compareFunc, userData) {
+    insertSorted(item, compareFunc) {
         return call("libgio-2.0.so.0", "g_list_store_insert_sorted", [
             {
                 type: { type: "gobject" },
@@ -203,14 +203,16 @@ export class ListStore extends GObject.GObject {
                 value: item?.ptr ?? item,
             },
             {
-                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: "int", size: 32, unsigned: true });
     }
     /**
@@ -249,21 +251,23 @@ export class ListStore extends GObject.GObject {
      * @param compareFunc - pairwise comparison function for sorting
      * @param userData - user data for @compare_func
      */
-    sort(compareFunc, userData) {
+    sort(compareFunc) {
         call("libgio-2.0.so.0", "g_list_store_sort", [
             {
                 type: { type: "gobject" },
                 value: this.ptr,
             },
             {
-                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/gio/memory-input-stream.d.ts

@@ -1,6 +1,7 @@
 import { Ref } from "@gtkx/native";
 import { Cancellable } from "./cancellable.js";
 import * as GLib from "../glib/index.js";
+import * as GObject from "../gobject/index.js";
 import { InputStream } from "./input-stream.js";
 /**
  * `GMemoryInputStream` is a class for using arbitrary
@@ -145,4 +146,6 @@ export declare class MemoryInputStream extends InputStream {
      * @param cancellable - optional #GCancellable object, %NULL to ignore.
      */
     truncate(offset: number, cancellable?: Cancellable | null): boolean;
+    connect(signal: "notify", handler: (self: MemoryInputStream, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/memory-input-stream.js

@@ -387,4 +387,22 @@ export class MemoryInputStream extends InputStream {
         }
         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], MemoryInputStream);
+            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/memory-output-stream.d.ts

@@ -2,6 +2,7 @@ import { Ref } from "@gtkx/native";
 import { PollableReturn } from "./enums.js";
 import { Cancellable } from "./cancellable.js";
 import * as GLib from "../glib/index.js";
+import * as GObject from "../gobject/index.js";
 import { OutputStream } from "./output-stream.js";
 /**
  * `GMemoryOutputStream` is a class for using arbitrary
@@ -197,4 +198,6 @@ export declare class MemoryOutputStream extends OutputStream {
      * @param cancellable - optional #GCancellable object, %NULL to ignore.
      */
     truncate(offset: number, cancellable?: Cancellable | null): boolean;
+    connect(signal: "notify", handler: (self: MemoryOutputStream, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/memory-output-stream.js

@@ -451,4 +451,22 @@ export class MemoryOutputStream extends OutputStream {
         }
         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], MemoryOutputStream);
+            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/menu.d.ts

@@ -1,16 +1,6 @@
 import { MenuItem } from "./menu-item.js";
 import * as GObject from "../gobject/index.js";
 import { MenuModel } from "./menu-model.js";
-/**
- * `GMenu` is a simple implementation of [class@Gio.MenuModel].
- * You populate a `GMenu` by adding [class@Gio.MenuItem] instances to it.
- *
- * There are some convenience functions to allow you to directly
- * add items (avoiding [class@Gio.MenuItem]) for the common cases. To add
- * a regular item, use [method@Gio.Menu.insert]. To add a section, use
- * [method@Gio.Menu.insert_section]. To add a submenu, use
- * [method@Gio.Menu.insert_submenu].
- */
 export declare class Menu extends MenuModel {
     /**
      * Creates a new #GMenu.
@@ -159,6 +149,7 @@ export declare class Menu extends MenuModel {
      * Removes all items in the menu.
      */
     removeAll(): void;
+    connect(signal: "items-changed", handler: (self: Menu, position: number, removed: number, added: number) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Menu, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/menu.js

@@ -11,6 +11,16 @@ import { MenuModel } from "./menu-model.js";
  * [method@Gio.Menu.insert_section]. To add a submenu, use
  * [method@Gio.Menu.insert_submenu].
  */
+const SIGNAL_META = {
+    "items-changed": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "int", size: 32, unsigned: false } },
+        ],
+        returnType: { type: "undefined" },
+    },
+};
 export class Menu extends MenuModel {
     /**
      * Creates a new #GMenu.
@@ -388,12 +398,24 @@ export class Menu extends MenuModel {
         ], { type: "undefined" });
     }
     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], Menu);
-            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/native-socket-address.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { SocketAddress } from "./socket-address.js";
 /**
  * A socket address of some unknown native type.
@@ -14,4 +15,6 @@ export declare class NativeSocketAddress extends SocketAddress {
     constructor(len: number, native?: number | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    connect(signal: "notify", handler: (self: NativeSocketAddress, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { getObject } from "@gtkx/ffi";
 import { SocketAddress } from "./socket-address.js";
 /**
  * A socket address of some unknown native type.
@@ -24,4 +25,22 @@ export class NativeSocketAddress extends SocketAddress {
             },
         ], { 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], NativeSocketAddress);
+            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/native-volume-monitor.d.ts

@@ -1,8 +1,23 @@
+import { Drive } from "./drive.js";
+import { Mount } from "./mount.js";
+import { Volume } from "./volume.js";
 import * as GObject from "../gobject/index.js";
 import { VolumeMonitor } from "./volume-monitor.js";
 export declare class NativeVolumeMonitor extends VolumeMonitor {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    connect(signal: "drive-changed", handler: (self: NativeVolumeMonitor, drive: Drive) => void, after?: boolean): number;
+    connect(signal: "drive-connected", handler: (self: NativeVolumeMonitor, drive: Drive) => void, after?: boolean): number;
+    connect(signal: "drive-disconnected", handler: (self: NativeVolumeMonitor, drive: Drive) => void, after?: boolean): number;
+    connect(signal: "drive-eject-button", handler: (self: NativeVolumeMonitor, drive: Drive) => void, after?: boolean): number;
+    connect(signal: "drive-stop-button", handler: (self: NativeVolumeMonitor, drive: Drive) => void, after?: boolean): number;
+    connect(signal: "mount-added", handler: (self: NativeVolumeMonitor, mount: Mount) => void, after?: boolean): number;
+    connect(signal: "mount-changed", handler: (self: NativeVolumeMonitor, mount: Mount) => void, after?: boolean): number;
+    connect(signal: "mount-pre-unmount", handler: (self: NativeVolumeMonitor, mount: Mount) => void, after?: boolean): number;
+    connect(signal: "mount-removed", handler: (self: NativeVolumeMonitor, mount: Mount) => void, after?: boolean): number;
+    connect(signal: "volume-added", handler: (self: NativeVolumeMonitor, volume: Volume) => void, after?: boolean): number;
+    connect(signal: "volume-changed", handler: (self: NativeVolumeMonitor, volume: Volume) => void, after?: boolean): number;
+    connect(signal: "volume-removed", handler: (self: NativeVolumeMonitor, volume: Volume) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: NativeVolumeMonitor, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/native-volume-monitor.js

@@ -1,6 +1,56 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { VolumeMonitor } from "./volume-monitor.js";
+const SIGNAL_META = {
+    "drive-changed": {
+        params: [{ type: { type: "gobject", borrowed: true } }],
+        returnType: { type: "undefined" },
+    },
+    "drive-connected": {
+        params: [{ type: { type: "gobject", borrowed: true } }],
+        returnType: { type: "undefined" },
+    },
+    "drive-disconnected": {
+        params: [{ type: { type: "gobject", borrowed: true } }],
+        returnType: { type: "undefined" },
+    },
+    "drive-eject-button": {
+        params: [{ type: { type: "gobject", borrowed: true } }],
+        returnType: { type: "undefined" },
+    },
+    "drive-stop-button": {
+        params: [{ type: { type: "gobject", borrowed: true } }],
+        returnType: { type: "undefined" },
+    },
+    "mount-added": {
+        params: [{ type: { type: "gobject", borrowed: true } }],
+        returnType: { type: "undefined" },
+    },
+    "mount-changed": {
+        params: [{ type: { type: "gobject", borrowed: true } }],
+        returnType: { type: "undefined" },
+    },
+    "mount-pre-unmount": {
+        params: [{ type: { type: "gobject", borrowed: true } }],
+        returnType: { type: "undefined" },
+    },
+    "mount-removed": {
+        params: [{ type: { type: "gobject", borrowed: true } }],
+        returnType: { type: "undefined" },
+    },
+    "volume-added": {
+        params: [{ type: { type: "gobject", borrowed: true } }],
+        returnType: { type: "undefined" },
+    },
+    "volume-changed": {
+        params: [{ type: { type: "gobject", borrowed: true } }],
+        returnType: { type: "undefined" },
+    },
+    "volume-removed": {
+        params: [{ type: { type: "gobject", borrowed: true } }],
+        returnType: { type: "undefined" },
+    },
+};
 export class NativeVolumeMonitor extends VolumeMonitor {
     constructor(...args) {
         super(...args);
@@ -13,12 +63,24 @@ export class NativeVolumeMonitor extends VolumeMonitor {
         ], { 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], NativeVolumeMonitor);
-            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 },