@gtkx/ffi 0.1.14 → 0.1.16

package/dist/generated/gio/dbus-object-manager-client.js

@@ -3,7 +3,30 @@ import { NativeError, wrapPtr } from "@gtkx/ffi";
 import { DBusConnection } from "./dbus-connection.js";
 import { DBusInterface } from "./dbus-interface.js";
 import { DBusObject } from "./dbus-object.js";
+import { DBusObjectProxy } from "./dbus-object-proxy.js";
+import { DBusProxy } from "./dbus-proxy.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "interface-proxy-properties-changed": [
+        {
+            type: { type: "gobject", borrowed: false },
+            getCls: () => DBusObjectProxy,
+        },
+        { type: { type: "gobject", borrowed: false }, getCls: () => DBusProxy },
+        { type: { type: "boxed", borrowed: false, innerType: "GVariant" } },
+        { type: { type: "array", itemType: { type: "string", borrowed: false } } },
+    ],
+    "interface-proxy-signal": [
+        {
+            type: { type: "gobject", borrowed: false },
+            getCls: () => DBusObjectProxy,
+        },
+        { type: { type: "gobject", borrowed: false }, getCls: () => DBusProxy },
+        { type: { type: "string", borrowed: false } },
+        { type: { type: "string", borrowed: false } },
+        { type: { type: "boxed", borrowed: false, innerType: "GVariant" } },
+    ],
+};
 export class DBusObjectManagerClient extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -379,4 +402,28 @@ export class DBusObjectManagerClient extends GObject.GObject {
         }
         return result;
     }
+    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], DBusObjectManagerClient);
+            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/dbus-object-manager-server.d.ts

@@ -17,4 +17,6 @@ export declare class DBusObjectManagerServer extends GObject.GObject {
     getObject(objectPath: string): DBusObject | null;
     getObjectPath(): string;
     getObjects(): DBusObject[];
+    connect(signal: "notify", handler: (self: DBusObjectManagerServer, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/dbus-object-manager-server.js

@@ -138,4 +138,18 @@ export class DBusObjectManagerServer extends GObject.GObject {
             },
         ], { type: "array", itemType: { type: "gobject" } });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], DBusObjectManagerServer);
+            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/dbus-object-proxy.d.ts

@@ -9,4 +9,6 @@ export declare class DBusObjectProxy extends GObject.GObject {
     getInterface(interfaceName: string): DBusInterface | null;
     getInterfaces(): DBusInterface[];
     getObjectPath(): string;
+    connect(signal: "notify", handler: (self: DBusObjectProxy, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/dbus-object-proxy.js

@@ -60,4 +60,18 @@ export class DBusObjectProxy extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], DBusObjectProxy);
+            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/dbus-object-skeleton.d.ts

@@ -1,5 +1,6 @@
 import { DBusInterface } from "./dbus-interface.js";
 import { DBusInterfaceSkeleton } from "./dbus-interface-skeleton.js";
+import { DBusMethodInvocation } from "./dbus-method-invocation.js";
 import * as GObject from "../gobject/index.js";
 export declare class DBusObjectSkeleton extends GObject.GObject {
     constructor(objectPath: string);
@@ -13,4 +14,7 @@ export declare class DBusObjectSkeleton extends GObject.GObject {
     getInterface(interfaceName: string): DBusInterface | null;
     getInterfaces(): DBusInterface[];
     getObjectPath(): string;
+    connect(signal: "authorize-method", handler: (self: DBusObjectSkeleton, _interface: DBusInterfaceSkeleton, invocation: DBusMethodInvocation) => boolean, after?: boolean): number;
+    connect(signal: "notify", handler: (self: DBusObjectSkeleton, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/dbus-object-skeleton.js

@@ -1,7 +1,21 @@
 import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { DBusInterface } from "./dbus-interface.js";
+import { DBusInterfaceSkeleton } from "./dbus-interface-skeleton.js";
+import { DBusMethodInvocation } from "./dbus-method-invocation.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "authorize-method": [
+        {
+            type: { type: "gobject", borrowed: false },
+            getCls: () => DBusInterfaceSkeleton,
+        },
+        {
+            type: { type: "gobject", borrowed: false },
+            getCls: () => DBusMethodInvocation,
+        },
+    ],
+};
 export class DBusObjectSkeleton extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -102,4 +116,28 @@ export class DBusObjectSkeleton extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    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], DBusObjectSkeleton);
+            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/dbus-proxy.d.ts

@@ -43,4 +43,8 @@ export declare class DBusProxy extends GObject.GObject {
     getInfo(): DBusInterfaceInfo;
     setObject(object?: DBusObject | null): void;
     init(cancellable?: Cancellable | null): boolean;
+    connect(signal: "g-properties-changed", handler: (self: DBusProxy, changedProperties: GLib.Variant, invalidatedProperties: string[]) => void, after?: boolean): number;
+    connect(signal: "g-signal", handler: (self: DBusProxy, senderName: string, signalName: string, parameters: GLib.Variant) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: DBusProxy, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -5,6 +5,17 @@ import { DBusConnection } from "./dbus-connection.js";
 import { DBusObject } from "./dbus-object.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "g-properties-changed": [
+        { type: { type: "boxed", borrowed: false, innerType: "GVariant" } },
+        { type: { type: "array", itemType: { type: "string", borrowed: false } } },
+    ],
+    "g-signal": [
+        { type: { type: "string", borrowed: false } },
+        { type: { type: "string", borrowed: false } },
+        { type: { type: "boxed", borrowed: false, innerType: "GVariant" } },
+    ],
+};
 export class DBusProxy extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -751,4 +762,28 @@ export class DBusProxy extends GObject.GObject {
         }
         return result;
     }
+    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], DBusProxy);
+            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/dbus-server.d.ts

@@ -1,6 +1,7 @@
 import { DBusServerFlags } from "./enums.js";
 import { Cancellable } from "./cancellable.js";
 import { DBusAuthObserver } from "./dbus-auth-observer.js";
+import { DBusConnection } from "./dbus-connection.js";
 import * as GObject from "../gobject/index.js";
 export declare class DBusServer extends GObject.GObject {
     constructor(address: string, flags: DBusServerFlags, guid: string, observer?: DBusAuthObserver | null, cancellable?: Cancellable | null);
@@ -13,4 +14,7 @@ export declare class DBusServer extends GObject.GObject {
     start(): void;
     stop(): void;
     init(cancellable?: Cancellable | null): boolean;
+    connect(signal: "new-connection", handler: (self: DBusServer, connection: DBusConnection) => boolean, after?: boolean): number;
+    connect(signal: "notify", handler: (self: DBusServer, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,6 +1,15 @@
 import { call } from "@gtkx/native";
-import { NativeError } from "@gtkx/ffi";
+import { NativeError, wrapPtr } from "@gtkx/ffi";
+import { DBusConnection } from "./dbus-connection.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "new-connection": [
+        {
+            type: { type: "gobject", borrowed: false },
+            getCls: () => DBusConnection,
+        },
+    ],
+};
 export class DBusServer extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -106,4 +115,28 @@ export class DBusServer extends GObject.GObject {
         }
         return result;
     }
+    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], DBusServer);
+            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/debug-controller-dbus.d.ts

@@ -1,5 +1,6 @@
 import { Cancellable } from "./cancellable.js";
 import { DBusConnection } from "./dbus-connection.js";
+import { DBusMethodInvocation } from "./dbus-method-invocation.js";
 import * as GObject from "../gobject/index.js";
 export declare class DebugControllerDBus extends GObject.GObject {
     constructor(connection: DBusConnection, cancellable?: Cancellable | null);
@@ -9,4 +10,7 @@ export declare class DebugControllerDBus extends GObject.GObject {
     getDebugEnabled(): boolean;
     setDebugEnabled(debugEnabled: boolean): void;
     init(cancellable?: Cancellable | null): boolean;
+    connect(signal: "authorize", handler: (self: DebugControllerDBus, invocation: DBusMethodInvocation) => boolean, after?: boolean): number;
+    connect(signal: "notify", handler: (self: DebugControllerDBus, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/debug-controller-dbus.js

@@ -1,6 +1,15 @@
 import { call } from "@gtkx/native";
-import { NativeError } from "@gtkx/ffi";
+import { NativeError, wrapPtr } from "@gtkx/ffi";
+import { DBusMethodInvocation } from "./dbus-method-invocation.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    authorize: [
+        {
+            type: { type: "gobject", borrowed: false },
+            getCls: () => DBusMethodInvocation,
+        },
+    ],
+};
 export class DebugControllerDBus extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -74,4 +83,28 @@ export class DebugControllerDBus extends GObject.GObject {
         }
         return result;
     }
+    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], DebugControllerDBus);
+            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/emblem.d.ts

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

package/dist/generated/gio/emblem.js

@@ -90,4 +90,18 @@ export class Emblem 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], Emblem);
+            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/emblemed-icon.d.ts

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

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

@@ -101,4 +101,18 @@ export class EmblemedIcon 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], EmblemedIcon);
+            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/file-enumerator.d.ts

@@ -19,4 +19,6 @@ export declare class FileEnumerator extends GObject.GObject {
     nextFilesAsync(numFiles: number, ioPriority: number, cancellable?: Cancellable | null, callback?: unknown | null, userData?: number | null): void;
     nextFilesFinish(result: AsyncResult): FileInfo[];
     setPending(pending: boolean): void;
+    connect(signal: "notify", handler: (self: FileEnumerator, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -270,4 +270,18 @@ export class FileEnumerator 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], FileEnumerator);
+            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/file-icon.d.ts

@@ -18,4 +18,6 @@ export declare class FileIcon extends GObject.GObject {
     load(size: number, type?: Ref<string> | null, cancellable?: Cancellable | null): InputStream;
     loadAsync(size: number, cancellable?: Cancellable | null, callback?: unknown | null, userData?: number | null): void;
     loadFinish(res: AsyncResult, type?: Ref<string> | null): InputStream;
+    connect(signal: "notify", handler: (self: FileIcon, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -162,4 +162,18 @@ export class FileIcon extends GObject.GObject {
         }
         return wrapPtr(ptr, InputStream);
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], FileIcon);
+            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/file-info.d.ts

@@ -77,4 +77,6 @@ export declare class FileInfo extends GObject.GObject {
     setSymbolicIcon(icon: Icon): void;
     setSymlinkTarget(symlinkTarget: string): void;
     unsetAttributeMask(): void;
+    connect(signal: "notify", handler: (self: FileInfo, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -900,4 +900,18 @@ export class FileInfo 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], FileInfo);
+            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/file-monitor.d.ts

@@ -8,4 +8,7 @@ export declare class FileMonitor extends GObject.GObject {
     emitEvent(child: File, eventType: FileMonitorEvent, otherFile?: File | null): void;
     isCancelled(): boolean;
     setRateLimit(limitMsecs: number): void;
+    connect(signal: "changed", handler: (self: FileMonitor, file: File, otherFile: File, eventType: FileMonitorEvent) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: FileMonitor, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,5 +1,13 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    changed: [
+        { type: { type: "gobject", borrowed: false } },
+        { type: { type: "gobject", borrowed: false } },
+        { type: { type: "int", size: 32, unsigned: false } },
+    ],
+};
 export class FileMonitor extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -63,4 +71,28 @@ export class FileMonitor extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    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], FileMonitor);
+            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/filename-completer.d.ts

@@ -5,4 +5,7 @@ export declare class FilenameCompleter extends GObject.GObject {
     getCompletionSuffix(initialText: string): string | null;
     getCompletions(initialText: string): string[];
     setDirsOnly(dirsOnly: boolean): void;
+    connect(signal: "got-completion-data", handler: (self: FilenameCompleter) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: FilenameCompleter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/filename-completer.js

@@ -1,5 +1,9 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "got-completion-data": [],
+};
 export class FilenameCompleter extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -46,4 +50,28 @@ export class FilenameCompleter extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    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], FilenameCompleter);
+            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/inet-address-mask.d.ts

@@ -14,4 +14,6 @@ export declare class InetAddressMask extends GObject.GObject {
     matches(address: InetAddress): boolean;
     toString(): string;
     init(cancellable?: Cancellable | null): boolean;
+    connect(signal: "notify", handler: (self: InetAddressMask, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -113,4 +113,18 @@ export class InetAddressMask 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], InetAddressMask);
+            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/inet-address.d.ts

@@ -24,4 +24,6 @@ export declare class InetAddress extends GObject.GObject {
     getNativeSize(): number;
     getScopeId(): number;
     toString(): string;
+    connect(signal: "notify", handler: (self: InetAddress, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }