@gtkx/ffi 0.1.15 → 0.1.16

package/dist/generated/gio/resolver.js

@@ -1,6 +1,9 @@
 import { call } from "@gtkx/native";
 import { NativeError, wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    reload: [],
+};
 export class Resolver extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -531,4 +534,28 @@ export class Resolver 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], Resolver);
+            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/settings-backend.d.ts

@@ -12,4 +12,6 @@ export declare class SettingsBackend extends GObject.GObject {
     pathChanged(path: string, originTag?: number | null): void;
     pathWritableChanged(path: string): void;
     writableChanged(key: string): void;
+    connect(signal: "notify", handler: (self: SettingsBackend, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/settings-backend.js

@@ -148,4 +148,18 @@ export class SettingsBackend 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], SettingsBackend);
+            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/settings.d.ts

@@ -56,4 +56,10 @@ export declare class Settings extends GObject.GObject {
     setUint(key: string, value: number): boolean;
     setUint64(key: string, value: number): boolean;
     setValue(key: string, value: GLib.Variant): boolean;
+    connect(signal: "change-event", handler: (self: Settings, keys: number[], nKeys: number) => boolean, after?: boolean): number;
+    connect(signal: "changed", handler: (self: Settings, key: string) => void, after?: boolean): number;
+    connect(signal: "writable-change-event", handler: (self: Settings, key: number) => boolean, after?: boolean): number;
+    connect(signal: "writable-changed", handler: (self: Settings, key: string) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Settings, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/settings.js

@@ -3,6 +3,22 @@ import { wrapPtr } from "@gtkx/ffi";
 import { Action } from "./action.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "change-event": [
+        {
+            type: {
+                type: "array",
+                itemType: { type: "int", size: 32, unsigned: true },
+            },
+        },
+        { type: { type: "int", size: 32, unsigned: false } },
+    ],
+    changed: [{ type: { type: "string", borrowed: false } }],
+    "writable-change-event": [
+        { type: { type: "int", size: 32, unsigned: true } },
+    ],
+    "writable-changed": [{ type: { type: "string", borrowed: false } }],
+};
 export class Settings extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -709,4 +725,28 @@ export class Settings extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    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], Settings);
+            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/simple-action-group.d.ts

@@ -28,4 +28,6 @@ export declare class SimpleActionGroup extends GObject.GObject {
     lookupAction(actionName: string): Action | null;
     removeAction(actionName: string): void;
     removeActionEntries(entries: unknown[], nEntries: number): void;
+    connect(signal: "notify", handler: (self: SimpleActionGroup, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/simple-action-group.js

@@ -417,4 +417,18 @@ export class SimpleActionGroup 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], SimpleActionGroup);
+            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/simple-action.d.ts

@@ -16,4 +16,8 @@ export declare class SimpleAction extends GObject.GObject {
     getState(): GLib.Variant | null;
     getStateHint(): GLib.Variant | null;
     getStateType(): GLib.VariantType | null;
+    connect(signal: "activate", handler: (self: SimpleAction, parameter: GLib.Variant) => void, after?: boolean): number;
+    connect(signal: "change-state", handler: (self: SimpleAction, value: GLib.Variant) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: SimpleAction, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -2,6 +2,14 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    activate: [
+        { type: { type: "boxed", borrowed: false, innerType: "GVariant" } },
+    ],
+    "change-state": [
+        { type: { type: "boxed", borrowed: false, innerType: "GVariant" } },
+    ],
+};
 export class SimpleAction extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -204,4 +212,28 @@ export class SimpleAction extends GObject.GObject {
             return null;
         return wrapPtr(ptr, GLib.VariantType);
     }
+    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], SimpleAction);
+            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/simple-async-result.d.ts

@@ -22,4 +22,6 @@ export declare class SimpleAsyncResult extends GObject.GObject {
     getUserData(): number | null;
     isTagged(sourceTag?: number | null): boolean;
     legacyPropagateError(): boolean;
+    connect(signal: "notify", handler: (self: SimpleAsyncResult, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/simple-async-result.js

@@ -234,4 +234,18 @@ export class SimpleAsyncResult 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], SimpleAsyncResult);
+            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/simple-proxy-resolver.d.ts

@@ -13,4 +13,6 @@ export declare class SimpleProxyResolver extends GObject.GObject {
     lookup(uri: string, cancellable?: Cancellable | null): string[];
     lookupAsync(uri: string, cancellable?: Cancellable | null, callback?: unknown | null, userData?: number | null): void;
     lookupFinish(result: AsyncResult): string[];
+    connect(signal: "notify", handler: (self: SimpleProxyResolver, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/simple-proxy-resolver.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 SimpleProxyResolver extends GObject.GObject {
     constructor(...args) {
@@ -156,4 +156,18 @@ export class SimpleProxyResolver 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], SimpleProxyResolver);
+            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/socket-address-enumerator.d.ts

@@ -8,4 +8,6 @@ export declare class SocketAddressEnumerator extends GObject.GObject {
     next(cancellable?: Cancellable | null): SocketAddress | null;
     nextAsync(cancellable?: Cancellable | null, callback?: unknown | null, userData?: number | null): void;
     nextFinish(result: AsyncResult): SocketAddress | null;
+    connect(signal: "notify", handler: (self: SocketAddressEnumerator, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

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

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

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

@@ -93,4 +93,18 @@ export class SocketAddress 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], SocketAddress);
+            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/socket-client.d.ts

@@ -1,10 +1,11 @@
-import { SocketFamily, SocketProtocol, SocketType, TlsCertificateFlags } from "./enums.js";
+import { SocketClientEvent, SocketFamily, SocketProtocol, SocketType, TlsCertificateFlags } from "./enums.js";
 import { AsyncResult } from "./async-result.js";
 import { Cancellable } from "./cancellable.js";
 import { ProxyResolver } from "./proxy-resolver.js";
 import { SocketAddress } from "./socket-address.js";
 import { SocketConnectable } from "./socket-connectable.js";
 import { SocketConnection } from "./socket-connection.js";
+import { IOStream } from "./iostream.js";
 import * as GObject from "../gobject/index.js";
 export declare class SocketClient extends GObject.GObject {
     constructor(...args: unknown[]);
@@ -40,4 +41,7 @@ export declare class SocketClient extends GObject.GObject {
     setTimeout(timeout: number): void;
     setTls(tls: boolean): void;
     setTlsValidationFlags(flags: TlsCertificateFlags): void;
+    on(signal: "event", handler: (self: SocketClient, event: SocketClientEvent, connectable: SocketConnectable, connection: IOStream) => void, after?: boolean): number;
+    on(signal: "notify", handler: (self: SocketClient, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    on(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -3,7 +3,15 @@ import { NativeError, wrapPtr } from "@gtkx/ffi";
 import { ProxyResolver } from "./proxy-resolver.js";
 import { SocketAddress } from "./socket-address.js";
 import { SocketConnection } from "./socket-connection.js";
+import { IOStream } from "./iostream.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    event: [
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "gobject", borrowed: false } },
+        { type: { type: "gobject", borrowed: false }, getCls: () => IOStream },
+    ],
+};
 export class SocketClient extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -570,4 +578,28 @@ export class SocketClient extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    on(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], SocketClient);
+            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/socket-control-message.d.ts

@@ -7,4 +7,6 @@ export declare class SocketControlMessage extends GObject.GObject {
     getMsgType(): number;
     getSize(): number;
     serialize(data: number): void;
+    connect(signal: "notify", handler: (self: SocketControlMessage, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/socket-control-message.js

@@ -72,4 +72,18 @@ export class SocketControlMessage 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], SocketControlMessage);
+            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/socket-listener.d.ts

@@ -1,10 +1,10 @@
 import { Ref } from "@gtkx/native";
-import { SocketProtocol, SocketType } from "./enums.js";
+import { SocketListenerEvent, SocketProtocol, SocketType } from "./enums.js";
 import { AsyncResult } from "./async-result.js";
 import { Cancellable } from "./cancellable.js";
-import { Socket } from "./socket.js";
 import { SocketAddress } from "./socket-address.js";
 import { SocketConnection } from "./socket-connection.js";
+import { Socket } from "./socket.js";
 import * as GObject from "../gobject/index.js";
 export declare class SocketListener extends GObject.GObject {
     constructor(...args: unknown[]);
@@ -21,4 +21,7 @@ export declare class SocketListener extends GObject.GObject {
     addSocket(socket: Socket, sourceObject?: GObject.GObject | null): boolean;
     close(): void;
     setBacklog(listenBacklog: number): void;
+    connect(signal: "event", handler: (self: SocketListener, event: SocketListenerEvent, socket: Socket) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: SocketListener, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,8 +1,14 @@
 import { call } from "@gtkx/native";
 import { NativeError, wrapPtr } from "@gtkx/ffi";
-import { Socket } from "./socket.js";
 import { SocketConnection } from "./socket-connection.js";
+import { Socket } from "./socket.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    event: [
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "gobject", borrowed: false }, getCls: () => Socket },
+    ],
+};
 export class SocketListener extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -337,4 +343,28 @@ export class SocketListener 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], SocketListener);
+            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/socket-service.d.ts

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

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

@@ -1,5 +1,16 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
+import { SocketConnection } from "./socket-connection.js";
 import { SocketListener } from "./socket-listener.js";
+const SIGNAL_META = {
+    incoming: [
+        {
+            type: { type: "gobject", borrowed: false },
+            getCls: () => SocketConnection,
+        },
+        { type: { type: "gobject", borrowed: false } },
+    ],
+};
 export class SocketService extends SocketListener {
     constructor(...args) {
         super(...args);
@@ -34,4 +45,28 @@ export class SocketService extends SocketListener {
             },
         ], { 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], SocketService);
+            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/socket.d.ts

@@ -72,4 +72,6 @@ export declare class Socket extends GObject.GObject {
     speaksIpv4(): boolean;
     createSource(condition: GLib.IOCondition, cancellable?: Cancellable | null): GLib.Source;
     init(cancellable?: Cancellable | null): boolean;
+    on(signal: "notify", handler: (self: Socket, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    on(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/socket.js

@@ -1486,4 +1486,18 @@ export class Socket extends GObject.GObject {
         }
         return result;
     }
+    on(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], Socket);
+            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/subprocess-launcher.d.ts

@@ -20,4 +20,6 @@ export declare class SubprocessLauncher extends GObject.GObject {
     takeStdinFd(fd: number): void;
     takeStdoutFd(fd: number): void;
     unsetenv(variable: string): void;
+    connect(signal: "notify", handler: (self: SubprocessLauncher, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/subprocess-launcher.js

@@ -219,4 +219,18 @@ export class SubprocessLauncher 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], SubprocessLauncher);
+            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/subprocess.d.ts

@@ -35,4 +35,6 @@ export declare class Subprocess extends GObject.GObject {
     waitCheckFinish(result: AsyncResult): boolean;
     waitFinish(result: AsyncResult): boolean;
     init(cancellable?: Cancellable | null): boolean;
+    connect(signal: "notify", handler: (self: Subprocess, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/subprocess.js

@@ -537,4 +537,18 @@ export class Subprocess 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], Subprocess);
+            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/task.d.ts

@@ -43,4 +43,6 @@ export declare class Task extends GObject.GObject {
     getUserData(): number | null;
     isTagged(sourceTag?: number | null): boolean;
     legacyPropagateError(): boolean;
+    connect(signal: "notify", handler: (self: Task, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }