@gtkx/ffi 0.1.15 → 0.1.16

package/dist/generated/gio/app-launch-context.js

@@ -1,5 +1,17 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "launch-failed": [{ type: { type: "string", borrowed: false } }],
+    "launch-started": [
+        { type: { type: "gobject", borrowed: false } },
+        { type: { type: "boxed", borrowed: false, innerType: "GVariant" } },
+    ],
+    launched: [
+        { type: { type: "gobject", borrowed: false } },
+        { type: { type: "boxed", borrowed: false, innerType: "GVariant" } },
+    ],
+};
 export class AppLaunchContext extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -90,4 +102,28 @@ export class AppLaunchContext 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], AppLaunchContext);
+            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/application-command-line.d.ts

@@ -20,4 +20,6 @@ export declare class ApplicationCommandLine extends GObject.GObject {
     printLiteral(message: string): void;
     printerrLiteral(message: string): void;
     setExitStatus(exitStatus: number): void;
+    connect(signal: "notify", handler: (self: ApplicationCommandLine, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/application-command-line.js

@@ -172,4 +172,18 @@ export class ApplicationCommandLine 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], ApplicationCommandLine);
+            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/application.d.ts

@@ -6,6 +6,7 @@ import { Cancellable } from "./cancellable.js";
 import { DBusConnection } from "./dbus-connection.js";
 import { File } from "./file.js";
 import { Notification } from "./notification.js";
+import { ApplicationCommandLine } from "./application-command-line.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 export declare class Application extends GObject.GObject {
@@ -69,4 +70,13 @@ export declare class Application extends GObject.GObject {
     lookupAction(actionName: string): Action | null;
     removeAction(actionName: string): void;
     removeActionEntries(entries: unknown[], nEntries: number): void;
+    connect(signal: "activate", handler: (self: Application) => void, after?: boolean): number;
+    connect(signal: "command-line", handler: (self: Application, commandLine: ApplicationCommandLine) => number, after?: boolean): number;
+    connect(signal: "handle-local-options", handler: (self: Application, options: GLib.VariantDict) => number, after?: boolean): number;
+    connect(signal: "name-lost", handler: (self: Application) => boolean, after?: boolean): number;
+    connect(signal: "open", handler: (self: Application, files: File[], nFiles: number, hint: string) => void, after?: boolean): number;
+    connect(signal: "shutdown", handler: (self: Application) => void, after?: boolean): number;
+    connect(signal: "startup", handler: (self: Application) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Application, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/application.js

@@ -2,8 +2,29 @@ import { call } from "@gtkx/native";
 import { NativeError, wrapPtr } from "@gtkx/ffi";
 import { Action } from "./action.js";
 import { DBusConnection } from "./dbus-connection.js";
+import { ApplicationCommandLine } from "./application-command-line.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    activate: [],
+    "command-line": [
+        {
+            type: { type: "gobject", borrowed: false },
+            getCls: () => ApplicationCommandLine,
+        },
+    ],
+    "handle-local-options": [
+        { type: { type: "boxed", borrowed: false, innerType: "GVariantDict" } },
+    ],
+    "name-lost": [],
+    open: [
+        { type: { type: "array", itemType: { type: "gobject", borrowed: false } } },
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "string", borrowed: false } },
+    ],
+    shutdown: [],
+    startup: [],
+};
 export class Application extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -814,4 +835,28 @@ export class Application 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], Application);
+            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/bytes-icon.d.ts

@@ -17,4 +17,6 @@ export declare class BytesIcon 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: BytesIcon, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -166,4 +166,18 @@ export class BytesIcon 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], BytesIcon);
+            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/cancellable.d.ts

@@ -16,4 +16,7 @@ export declare class Cancellable extends GObject.GObject {
     reset(): void;
     setErrorIfCancelled(): boolean;
     sourceNew(): GLib.Source;
+    on(signal: "cancelled", handler: (self: Cancellable) => void, after?: boolean): number;
+    on(signal: "notify", handler: (self: Cancellable, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    on(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/cancellable.js

@@ -2,6 +2,9 @@ import { call } from "@gtkx/native";
 import { NativeError, wrapPtr } from "@gtkx/ffi";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    cancelled: [],
+};
 export class Cancellable extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -157,4 +160,28 @@ export class Cancellable extends GObject.GObject {
         });
         return wrapPtr(ptr, GLib.Source);
     }
+    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], Cancellable);
+            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/charset-converter.d.ts

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

package/dist/generated/gio/charset-converter.js

@@ -180,4 +180,18 @@ export class CharsetConverter 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], CharsetConverter);
+            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/credentials.d.ts

@@ -9,4 +9,6 @@ export declare class Credentials extends GObject.GObject {
     setNative(nativeType: CredentialsType, native: number): void;
     setUnixUser(uid: number): boolean;
     toString(): string;
+    connect(signal: "notify", handler: (self: Credentials, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/credentials.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 Credentials extends GObject.GObject {
     constructor(...args) {
@@ -139,4 +139,18 @@ export class Credentials 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], Credentials);
+            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-action-group.d.ts

@@ -22,4 +22,6 @@ export declare class DBusActionGroup extends GObject.GObject {
     queryAction(actionName: string, enabled: Ref<boolean>, parameterType?: Ref<GLib.VariantType> | null, stateType?: Ref<GLib.VariantType> | null, stateHint?: Ref<GLib.Variant> | null, state?: Ref<GLib.Variant> | null): boolean;
     activateActionFull(actionName: string, platformData: GLib.Variant, parameter?: GLib.Variant | null): void;
     changeActionStateFull(actionName: string, value: GLib.Variant, platformData: GLib.Variant): void;
+    connect(signal: "notify", handler: (self: DBusActionGroup, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -362,4 +362,18 @@ export class DBusActionGroup 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], DBusActionGroup);
+            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-auth-observer.d.ts

@@ -6,4 +6,8 @@ export declare class DBusAuthObserver extends GObject.GObject {
     protected createPtr(_args: unknown[]): unknown;
     allowMechanism(mechanism: string): boolean;
     authorizeAuthenticatedPeer(stream: IOStream, credentials?: Credentials | null): boolean;
+    connect(signal: "allow-mechanism", handler: (self: DBusAuthObserver, mechanism: string) => boolean, after?: boolean): number;
+    connect(signal: "authorize-authenticated-peer", handler: (self: DBusAuthObserver, stream: IOStream, credentials: Credentials) => boolean, after?: boolean): number;
+    connect(signal: "notify", handler: (self: DBusAuthObserver, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/dbus-auth-observer.js

@@ -1,5 +1,15 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
+import { Credentials } from "./credentials.js";
+import { IOStream } from "./iostream.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "allow-mechanism": [{ type: { type: "string", borrowed: false } }],
+    "authorize-authenticated-peer": [
+        { type: { type: "gobject", borrowed: false }, getCls: () => IOStream },
+        { type: { type: "gobject", borrowed: false }, getCls: () => Credentials },
+    ],
+};
 export class DBusAuthObserver extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -38,4 +48,28 @@ export class DBusAuthObserver 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], DBusAuthObserver);
+            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-connection.d.ts

@@ -67,4 +67,7 @@ export declare class DBusConnection extends GObject.GObject {
     initFinish(res: AsyncResult): boolean;
     newFinish(res: AsyncResult): GObject.GObject;
     init(cancellable?: Cancellable | null): boolean;
+    connect(signal: "closed", handler: (self: DBusConnection, remotePeerVanished: boolean, error: GLib.GError) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: DBusConnection, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -5,6 +5,12 @@ import { DBusMessage } from "./dbus-message.js";
 import { IOStream } from "./iostream.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    closed: [
+        { type: { type: "boolean" } },
+        { type: { type: "boxed", borrowed: false, innerType: "GError" } },
+    ],
+};
 export class DBusConnection extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -1450,4 +1456,28 @@ export class DBusConnection 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], DBusConnection);
+            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-interface-skeleton.d.ts

@@ -2,6 +2,7 @@ import { DBusInterfaceSkeletonFlags } from "./enums.js";
 import { DBusInterfaceInfo } from "./dbus-interface-info.js";
 import { DBusConnection } from "./dbus-connection.js";
 import { DBusObject } from "./dbus-object.js";
+import { DBusMethodInvocation } from "./dbus-method-invocation.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 export declare class DBusInterfaceSkeleton extends GObject.GObject {
@@ -22,4 +23,7 @@ export declare class DBusInterfaceSkeleton extends GObject.GObject {
     unexportFromConnection(connection: DBusConnection): void;
     dupObject(): DBusObject | null;
     setObject(object?: DBusObject | null): void;
+    connect(signal: "g-authorize-method", handler: (self: DBusInterfaceSkeleton, invocation: DBusMethodInvocation) => boolean, after?: boolean): number;
+    connect(signal: "notify", handler: (self: DBusInterfaceSkeleton, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -3,8 +3,17 @@ import { NativeError, wrapPtr } from "@gtkx/ffi";
 import { DBusInterfaceInfo } from "./dbus-interface-info.js";
 import { DBusConnection } from "./dbus-connection.js";
 import { DBusObject } from "./dbus-object.js";
+import { DBusMethodInvocation } from "./dbus-method-invocation.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "g-authorize-method": [
+        {
+            type: { type: "gobject", borrowed: false },
+            getCls: () => DBusMethodInvocation,
+        },
+    ],
+};
 export class DBusInterfaceSkeleton extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -194,4 +203,28 @@ export class DBusInterfaceSkeleton 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], DBusInterfaceSkeleton);
+            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-menu-model.d.ts

@@ -1,7 +1,10 @@
 import { DBusConnection } from "./dbus-connection.js";
+import * as GObject from "../gobject/index.js";
 import { MenuModel } from "./menu-model.js";
 export declare class DBusMenuModel extends MenuModel {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     static get(connection: DBusConnection, objectPath: string, busName?: string | null): DBusMenuModel;
+    connect(signal: "notify", handler: (self: DBusMenuModel, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

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

@@ -53,4 +53,6 @@ export declare class DBusMessage extends GObject.GObject {
     setUnixFdList(fdList?: UnixFDList | null): void;
     toBlob(outSize: Ref<number>, capabilities: DBusCapabilityFlags): number[];
     toGerror(): boolean;
+    connect(signal: "notify", handler: (self: DBusMessage, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -618,4 +618,18 @@ export class DBusMessage 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], DBusMessage);
+            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-method-invocation.d.ts

@@ -22,4 +22,6 @@ export declare class DBusMethodInvocation extends GObject.GObject {
     returnGerror(error: GLib.GError): void;
     returnValue(parameters?: GLib.Variant | null): void;
     returnValueWithUnixFdList(parameters?: GLib.Variant | null, fdList?: UnixFDList | null): void;
+    connect(signal: "notify", handler: (self: DBusMethodInvocation, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/dbus-method-invocation.js

@@ -197,4 +197,18 @@ export class DBusMethodInvocation 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], DBusMethodInvocation);
+            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-manager-client.d.ts

@@ -4,6 +4,9 @@ import { Cancellable } from "./cancellable.js";
 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 GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 export declare class DBusObjectManagerClient extends GObject.GObject {
     constructor(res: AsyncResult);
@@ -26,4 +29,8 @@ export declare class DBusObjectManagerClient extends GObject.GObject {
     getObjectPath(): string;
     getObjects(): DBusObject[];
     init(cancellable?: Cancellable | null): boolean;
+    connect(signal: "interface-proxy-properties-changed", handler: (self: DBusObjectManagerClient, objectProxy: DBusObjectProxy, interfaceProxy: DBusProxy, changedProperties: GLib.Variant, invalidatedProperties: string[]) => void, after?: boolean): number;
+    connect(signal: "interface-proxy-signal", handler: (self: DBusObjectManagerClient, objectProxy: DBusObjectProxy, interfaceProxy: DBusProxy, senderName: string, signalName: string, parameters: GLib.Variant) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: DBusObjectManagerClient, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }