@gtkx/ffi 0.1.15 → 0.1.16

package/dist/generated/gio/task.js

@@ -519,4 +519,18 @@ export class Task extends GObject.GObject {
         }
         return result;
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], Task);
+            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 }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/test-dbus.d.ts

@@ -11,4 +11,6 @@ export declare class TestDBus extends GObject.GObject {
     getFlags(): TestDBusFlags;
     stop(): void;
     up(): void;
+    connect(signal: "notify", handler: (self: TestDBus, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/test-dbus.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
 export class TestDBus extends GObject.GObject {
     constructor(...args) {
@@ -68,4 +69,18 @@ export class TestDBus extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], TestDBus);
+            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 }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/themed-icon.d.ts

@@ -14,4 +14,6 @@ export declare class ThemedIcon extends GObject.GObject {
     hash(): number;
     serialize(): GLib.Variant | null;
     toString(): string | null;
+    connect(signal: "notify", handler: (self: ThemedIcon, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/themed-icon.js

@@ -113,4 +113,18 @@ export class ThemedIcon extends GObject.GObject {
             },
         ], { type: "string" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], ThemedIcon);
+            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 }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

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

@@ -1,5 +1,8 @@
+import * as GObject from "../gobject/index.js";
 import { Resolver } from "./resolver.js";
 export declare class ThreadedResolver extends Resolver {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    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

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import { Resolver } from "./resolver.js";
 export class ThreadedResolver extends Resolver {
     constructor(...args) {
@@ -15,4 +16,18 @@ export class ThreadedResolver extends Resolver {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], ThreadedResolver);
+            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 }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

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

@@ -1,6 +1,12 @@
+import { SocketConnection } from "./socket-connection.js";
+import * as GObject from "../gobject/index.js";
 import { SocketService } from "./socket-service.js";
 export declare class ThreadedSocketService extends SocketService {
     constructor(maxThreads: number);
     constructor(...args: unknown[]);
     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: "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,23 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
+import { SocketConnection } from "./socket-connection.js";
 import { SocketService } from "./socket-service.js";
+const SIGNAL_META = {
+    run: [
+        {
+            type: { type: "gobject", borrowed: false },
+            getCls: () => SocketConnection,
+        },
+        { type: { type: "gobject", borrowed: false } },
+    ],
+    incoming: [
+        {
+            type: { type: "gobject", borrowed: false },
+            getCls: () => SocketConnection,
+        },
+        { type: { type: "gobject", borrowed: false } },
+    ],
+};
 export class ThreadedSocketService extends SocketService {
     constructor(...args) {
         super(...args);
@@ -13,4 +31,28 @@ export class ThreadedSocketService extends SocketService {
             },
         ], { type: "gobject", borrowed: false });
     }
+    connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], ThreadedSocketService);
+            const signalArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...signalArgs);
+            const wrapped = meta.map((m, i) => {
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(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 },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/tls-certificate.d.ts

@@ -21,4 +21,6 @@ export declare class TlsCertificate extends GObject.GObject {
     getSubjectName(): string | null;
     isSame(certTwo: TlsCertificate): boolean;
     verify(identity?: SocketConnectable | null, trustedCa?: TlsCertificate | null): TlsCertificateFlags;
+    connect(signal: "notify", handler: (self: TlsCertificate, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/tls-certificate.js

@@ -230,4 +230,18 @@ export class TlsCertificate extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], TlsCertificate);
+            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 }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

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

@@ -6,7 +6,10 @@ import { TlsCertificate } from "./tls-certificate.js";
 import { IOStream } from "./iostream.js";
 const SIGNAL_META = {
     "accept-certificate": [
-        { type: { type: "gobject", borrowed: false }, cls: TlsCertificate },
+        {
+            type: { type: "gobject", borrowed: false },
+            getCls: () => TlsCertificate,
+        },
         { type: { type: "int", size: 32, unsigned: false } },
     ],
 };
@@ -354,8 +357,8 @@ export class TlsConnection extends IOStream {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
                 }
                 return signalArgs[i];
             });

package/dist/generated/gio/tls-database.d.ts

@@ -22,4 +22,6 @@ export declare class TlsDatabase extends GObject.GObject {
     verifyChain(chain: TlsCertificate, purpose: string, flags: TlsDatabaseVerifyFlags, identity?: SocketConnectable | null, interaction?: TlsInteraction | null, cancellable?: Cancellable | null): TlsCertificateFlags;
     verifyChainAsync(chain: TlsCertificate, purpose: string, flags: TlsDatabaseVerifyFlags, identity?: SocketConnectable | null, interaction?: TlsInteraction | null, cancellable?: Cancellable | null, callback?: unknown | null, userData?: number | null): void;
     verifyChainFinish(result: AsyncResult): TlsCertificateFlags;
+    connect(signal: "notify", handler: (self: TlsDatabase, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/tls-database.js

@@ -455,4 +455,18 @@ export class TlsDatabase extends GObject.GObject {
         }
         return _result;
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], TlsDatabase);
+            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 }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/tls-interaction.d.ts

@@ -15,4 +15,6 @@ export declare class TlsInteraction extends GObject.GObject {
     requestCertificate(connection: TlsConnection, flags: TlsCertificateRequestFlags, cancellable?: Cancellable | null): TlsInteractionResult;
     requestCertificateAsync(connection: TlsConnection, flags: TlsCertificateRequestFlags, cancellable?: Cancellable | null, callback?: unknown | null, userData?: number | null): void;
     requestCertificateFinish(result: AsyncResult): TlsInteractionResult;
+    connect(signal: "notify", handler: (self: TlsInteraction, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/tls-interaction.js

@@ -1,5 +1,5 @@
 import { call } from "@gtkx/native";
-import { NativeError } from "@gtkx/ffi";
+import { NativeError, wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
 export class TlsInteraction extends GObject.GObject {
     constructor(...args) {
@@ -260,4 +260,18 @@ export class TlsInteraction extends GObject.GObject {
         }
         return _result;
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], TlsInteraction);
+            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 }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/tls-password.d.ts

@@ -14,4 +14,6 @@ export declare class TlsPassword extends GObject.GObject {
     setValue(value: number[], length: number): void;
     setValueFull(value: number[], length: number, destroy?: () => void | null): void;
     setWarning(warning: string): void;
+    connect(signal: "notify", handler: (self: TlsPassword, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/tls-password.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
 export class TlsPassword extends GObject.GObject {
     constructor(...args) {
@@ -134,4 +135,18 @@ export class TlsPassword extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], TlsPassword);
+            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 }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

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

@@ -9,4 +9,6 @@ export declare class UnixFDList extends GObject.GObject {
     getLength(): number;
     peekFds(length?: Ref<number> | null): number[];
     stealFds(length?: Ref<number> | null): number[];
+    connect(signal: "notify", handler: (self: UnixFDList, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -121,4 +121,18 @@ export class UnixFDList extends GObject.GObject {
             },
         ], { type: "array", itemType: { type: "int", size: 32, unsigned: false } });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], UnixFDList);
+            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 }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/vfs.d.ts

@@ -12,4 +12,6 @@ export declare class Vfs extends GObject.GObject {
     parseName(parseName: string): File;
     registerUriScheme(scheme: string, uriFunc?: (...args: unknown[]) => unknown | null, uriData?: number | null, uriDestroy?: () => void | null, parseNameFunc?: (...args: unknown[]) => unknown | null, parseNameData?: number | null, parseNameDestroy?: () => void | null): boolean;
     unregisterUriScheme(scheme: string): boolean;
+    connect(signal: "notify", handler: (self: Vfs, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/vfs.js

@@ -134,4 +134,18 @@ export class Vfs extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], Vfs);
+            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 }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/volume-monitor.d.ts

@@ -12,4 +12,18 @@ export declare class VolumeMonitor extends GObject.GObject {
     getMounts(): Mount[];
     getVolumeForUuid(uuid: string): Volume | null;
     getVolumes(): Volume[];
+    connect(signal: "drive-changed", handler: (self: VolumeMonitor, drive: Drive) => void, after?: boolean): number;
+    connect(signal: "drive-connected", handler: (self: VolumeMonitor, drive: Drive) => void, after?: boolean): number;
+    connect(signal: "drive-disconnected", handler: (self: VolumeMonitor, drive: Drive) => void, after?: boolean): number;
+    connect(signal: "drive-eject-button", handler: (self: VolumeMonitor, drive: Drive) => void, after?: boolean): number;
+    connect(signal: "drive-stop-button", handler: (self: VolumeMonitor, drive: Drive) => void, after?: boolean): number;
+    connect(signal: "mount-added", handler: (self: VolumeMonitor, mount: Mount) => void, after?: boolean): number;
+    connect(signal: "mount-changed", handler: (self: VolumeMonitor, mount: Mount) => void, after?: boolean): number;
+    connect(signal: "mount-pre-unmount", handler: (self: VolumeMonitor, mount: Mount) => void, after?: boolean): number;
+    connect(signal: "mount-removed", handler: (self: VolumeMonitor, mount: Mount) => void, after?: boolean): number;
+    connect(signal: "volume-added", handler: (self: VolumeMonitor, volume: Volume) => void, after?: boolean): number;
+    connect(signal: "volume-changed", handler: (self: VolumeMonitor, volume: Volume) => void, after?: boolean): number;
+    connect(signal: "volume-removed", handler: (self: VolumeMonitor, volume: Volume) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: VolumeMonitor, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -3,6 +3,20 @@ import { wrapPtr } from "@gtkx/ffi";
 import { Mount } from "./mount.js";
 import { Volume } from "./volume.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "drive-changed": [{ type: { type: "gobject", borrowed: false } }],
+    "drive-connected": [{ type: { type: "gobject", borrowed: false } }],
+    "drive-disconnected": [{ type: { type: "gobject", borrowed: false } }],
+    "drive-eject-button": [{ type: { type: "gobject", borrowed: false } }],
+    "drive-stop-button": [{ type: { type: "gobject", borrowed: false } }],
+    "mount-added": [{ type: { type: "gobject", borrowed: false } }],
+    "mount-changed": [{ type: { type: "gobject", borrowed: false } }],
+    "mount-pre-unmount": [{ type: { type: "gobject", borrowed: false } }],
+    "mount-removed": [{ type: { type: "gobject", borrowed: false } }],
+    "volume-added": [{ type: { type: "gobject", borrowed: false } }],
+    "volume-changed": [{ type: { type: "gobject", borrowed: false } }],
+    "volume-removed": [{ type: { type: "gobject", borrowed: false } }],
+};
 export class VolumeMonitor extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -87,4 +101,28 @@ export class VolumeMonitor extends GObject.GObject {
             },
         ], { type: "array", itemType: { type: "gobject" } });
     }
+    connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], VolumeMonitor);
+            const signalArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...signalArgs);
+            const wrapped = meta.map((m, i) => {
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(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 },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/zlib-compressor.d.ts

@@ -14,4 +14,6 @@ export declare class ZlibCompressor extends GObject.GObject {
     convert(inbuf: number[], inbufSize: number, outbuf: number[], outbufSize: number, flags: ConverterFlags, bytesRead: Ref<number>, bytesWritten: Ref<number>): ConverterResult;
     convertBytes(bytes: GLib.Bytes): GLib.Bytes;
     reset(): void;
+    connect(signal: "notify", handler: (self: ZlibCompressor, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/zlib-compressor.js

@@ -168,4 +168,18 @@ export class ZlibCompressor extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], ZlibCompressor);
+            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 }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gio/zlib-decompressor.d.ts

@@ -11,4 +11,6 @@ export declare class ZlibDecompressor extends GObject.GObject {
     convert(inbuf: number[], inbufSize: number, outbuf: number[], outbufSize: number, flags: ConverterFlags, bytesRead: Ref<number>, bytesWritten: Ref<number>): ConverterResult;
     convertBytes(bytes: GLib.Bytes): GLib.Bytes;
     reset(): void;
+    connect(signal: "notify", handler: (self: ZlibDecompressor, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/zlib-decompressor.js

@@ -132,4 +132,18 @@ export class ZlibDecompressor extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], ZlibDecompressor);
+            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 }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gobject/binding-group.js

@@ -3,7 +3,9 @@ import { wrapPtr } from "@gtkx/ffi";
 import { ParamSpec } from "./param-spec.js";
 import { GObject } from "./object.js";
 const SIGNAL_META = {
-    notify: [{ type: { type: "gobject", borrowed: false }, cls: ParamSpec }],
+    notify: [
+        { type: { type: "gobject", borrowed: false }, getCls: () => ParamSpec },
+    ],
 };
 export class BindingGroup extends GObject {
     constructor(...args) {
@@ -152,8 +154,8 @@ export class BindingGroup extends GObject {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
                 }
                 return signalArgs[i];
             });

package/dist/generated/gobject/binding.js

@@ -3,7 +3,9 @@ import { wrapPtr } from "@gtkx/ffi";
 import { ParamSpec } from "./param-spec.js";
 import { GObject } from "./object.js";
 const SIGNAL_META = {
-    notify: [{ type: { type: "gobject", borrowed: false }, cls: ParamSpec }],
+    notify: [
+        { type: { type: "gobject", borrowed: false }, getCls: () => ParamSpec },
+    ],
 };
 export class Binding extends GObject {
     constructor(...args) {
@@ -106,8 +108,8 @@ export class Binding extends GObject {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
                 }
                 return signalArgs[i];
             });

package/dist/generated/gobject/initially-unowned.js

@@ -3,7 +3,9 @@ import { wrapPtr } from "@gtkx/ffi";
 import { ParamSpec } from "./param-spec.js";
 import { GObject } from "./object.js";
 const SIGNAL_META = {
-    notify: [{ type: { type: "gobject", borrowed: false }, cls: ParamSpec }],
+    notify: [
+        { type: { type: "gobject", borrowed: false }, getCls: () => ParamSpec },
+    ],
 };
 export class InitiallyUnowned extends GObject {
     constructor(...args) {
@@ -26,8 +28,8 @@ export class InitiallyUnowned extends GObject {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
                 }
                 return signalArgs[i];
             });

package/dist/generated/gobject/object.js

@@ -2,7 +2,9 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { ParamSpec } from "./param-spec.js";
 const SIGNAL_META = {
-    notify: [{ type: { type: "gobject", borrowed: false }, cls: ParamSpec }],
+    notify: [
+        { type: { type: "gobject", borrowed: false }, getCls: () => ParamSpec },
+    ],
 };
 export class GObject {
     ptr;
@@ -431,8 +433,8 @@ export class GObject {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
                 }
                 return signalArgs[i];
             });

package/dist/generated/gobject/signal-group.js

@@ -3,9 +3,11 @@ import { wrapPtr } from "@gtkx/ffi";
 import { ParamSpec } from "./param-spec.js";
 import { GObject } from "./object.js";
 const SIGNAL_META = {
-    bind: [{ type: { type: "gobject", borrowed: false }, cls: GObject }],
+    bind: [{ type: { type: "gobject", borrowed: false }, getCls: () => GObject }],
     unbind: [],
-    notify: [{ type: { type: "gobject", borrowed: false }, cls: ParamSpec }],
+    notify: [
+        { type: { type: "gobject", borrowed: false }, getCls: () => ParamSpec },
+    ],
 };
 export class SignalGroup extends GObject {
     constructor(...args) {
@@ -141,8 +143,8 @@ export class SignalGroup extends GObject {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
                 }
                 return signalArgs[i];
             });