@gtkx/ffi 0.10.0 → 0.10.2

package/dist/generated/gio/subprocess.js

@@ -70,6 +70,12 @@ import * as GObject from "../gobject/index.js";
  * account the fact that your program will not automatically be killed
  * if it tries to write to `stdout` after it has been closed.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class Subprocess extends GObject.GObject {
     static glibTypeName = "GSubprocess";
     static objectType = "gobject";
@@ -806,13 +812,25 @@ export class Subprocess extends GObject.GObject {
         return result;
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gio/tcp-connection.d.ts

@@ -1,9 +1,5 @@
 import * as GObject from "../gobject/index.js";
 import { SocketConnection } from "./socket-connection.js";
-/**
- * This is the subclass of {@link Gio.SocketConnection} that is created
- * for TCP/IP sockets.
- */
 export declare class TcpConnection extends SocketConnection {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

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

@@ -2,11 +2,18 @@ import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import { SocketConnection } from "./socket-connection.js";
 /**
  * This is the subclass of {@link Gio.SocketConnection} that is created
  * for TCP/IP sockets.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class TcpConnection extends SocketConnection {
     static glibTypeName = "GTcpConnection";
     static objectType = "gobject";
@@ -68,13 +75,25 @@ export class TcpConnection extends SocketConnection {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gio/tcp-wrapper-connection.d.ts

@@ -2,14 +2,6 @@ import { IOStream } from "./iostream.js";
 import { Socket } from "./socket.js";
 import * as GObject from "../gobject/index.js";
 import { TcpConnection } from "./tcp-connection.js";
-/**
- * A `GTcpWrapperConnection` can be used to wrap a {@link Gio.IOStream} that is
- * based on a {@link Gio.Socket}, but which is not actually a
- * {@link Gio.SocketConnection}. This is used by {@link Gio.SocketClient} so
- * that it can always return a {@link Gio.SocketConnection}, even when the
- * connection it has actually created is not directly a
- * {@link Gio.SocketConnection}.
- */
 export declare class TcpWrapperConnection extends TcpConnection {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gio/tcp-wrapper-connection.js

@@ -2,6 +2,7 @@ import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import { TcpConnection } from "./tcp-connection.js";
 /**
  * A `GTcpWrapperConnection` can be used to wrap a {@link Gio.IOStream} that is
@@ -11,6 +12,12 @@ import { TcpConnection } from "./tcp-connection.js";
  * connection it has actually created is not directly a
  * {@link Gio.SocketConnection}.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class TcpWrapperConnection extends TcpConnection {
     static glibTypeName = "GTcpWrapperConnection";
     static objectType = "gobject";
@@ -54,13 +61,25 @@ export class TcpWrapperConnection extends TcpConnection {
         return getNativeObject(ptr);
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [

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

@@ -1,86 +1,5 @@
 import { TestDBusFlags } from "./enums.js";
 import * as GObject from "../gobject/index.js";
-/**
- * A helper class for testing code which uses D-Bus without touching the user’s
- * session bus.
- *
- * Note that `GTestDBus` modifies the user’s environment, calling
- * [`setenv()`](man:setenv(3)). This is not thread-safe, so all `GTestDBus`
- * calls should be completed before threads are spawned, or should have
- * appropriate locking to ensure no access conflicts to environment variables
- * shared between `GTestDBus` and other threads.
- *
- * ## Creating unit tests using `GTestDBus`
- *
- * Testing of D-Bus services can be tricky because normally we only ever run
- * D-Bus services over an existing instance of the D-Bus daemon thus we
- * usually don’t activate D-Bus services that are not yet installed into the
- * target system. The `GTestDBus` object makes this easier for us by taking care
- * of the lower level tasks such as running a private D-Bus daemon and looking
- * up uninstalled services in customizable locations, typically in your source
- * code tree.
- *
- * The first thing you will need is a separate service description file for the
- * D-Bus daemon. Typically a `services` subdirectory of your `tests` directory
- * is a good place to put this file.
- *
- * The service file should list your service along with an absolute path to the
- * uninstalled service executable in your source tree. Using autotools we would
- * achieve this by adding a file such as `my-server.service.in` in the services
- * directory and have it processed by configure.
- *
- * ```
- * [D-BUS Service]
- * Name=org.gtk.GDBus.Examples.ObjectManager
- * Exec=`abs_top_builddir`@/gio/tests/gdbus-example-objectmanager-server
- * ```
- *
- * You will also need to indicate this service directory in your test
- * fixtures, so you will need to pass the path while compiling your
- * test cases. Typically this is done with autotools with an added
- * preprocessor flag specified to compile your tests such as:
- *
- * ```
- * -DTEST_SERVICES=\""$(abs_top_builddir)/tests/services"\"
- * ```
- *
- * Once you have a service definition file which is local to your source tree,
- * you can proceed to set up a GTest fixture using the `GTestDBus` scaffolding.
- *
- * An example of a test fixture for D-Bus services can be found
- * here:
- * [gdbus-test-fixture.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-test-fixture.c)
- *
- * Note that these examples only deal with isolating the D-Bus aspect of your
- * service. To successfully run isolated unit tests on your service you may need
- * some additional modifications to your test case fixture. For example; if your
- * service uses {@link Gio.Settings} and installs a schema then it is important
- * that your test service not load the schema in the ordinary installed location
- * (chances are that your service and schema files are not yet installed, or
- * worse; there is an older version of the schema file sitting in the install
- * location).
- *
- * Most of the time we can work around these obstacles using the
- * environment. Since the environment is inherited by the D-Bus daemon
- * created by `GTestDBus` and then in turn inherited by any services the
- * D-Bus daemon activates, using the setup routine for your fixture is
- * a practical place to help sandbox your runtime environment. For the
- * rather typical GSettings case we can work around this by setting
- * `GSETTINGS_SCHEMA_DIR` to the in tree directory holding your schemas
- * in the above `fixture_setup()` routine.
- *
- * The GSettings schemas need to be locally pre-compiled for this to work. This
- * can be achieved by compiling the schemas locally as a step before running
- * test cases, an autotools setup might do the following in the directory
- * holding schemas:
- *
- * ```
- *     all-am:
- *             $(GLIB_COMPILE_SCHEMAS) .
- *
- *     CLEANFILES += gschemas.compiled
- * ```
- */
 export declare class TestDBus extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

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

@@ -84,6 +84,12 @@ import * as GObject from "../gobject/index.js";
  *     CLEANFILES += gschemas.compiled
  * ```
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class TestDBus extends GObject.GObject {
     static glibTypeName = "GTestDBus";
     static objectType = "gobject";
@@ -211,13 +217,25 @@ export class TestDBus extends GObject.GObject {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [

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

@@ -1,17 +1,6 @@
 import { Icon } from "./icon.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
-/**
- * `GThemedIcon` is an implementation of {@link Gio.Icon} that supports icon
- * themes.
- *
- * `GThemedIcon` contains a list of all of the icons present in an icon
- * theme, so that icons can be looked up quickly. `GThemedIcon` does
- * not provide actual pixmaps for icons, just the icon names.
- * Ideally something like {@link Gtk.IconTheme.choose_icon} should be used to
- * resolve the list of names so that fallback icons work nicely with
- * themes that inherit other themes.
- */
 export declare class ThemedIcon extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

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

@@ -15,6 +15,12 @@ import * as GObject from "../gobject/index.js";
  * resolve the list of names so that fallback icons work nicely with
  * themes that inherit other themes.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class ThemedIcon extends GObject.GObject {
     static glibTypeName = "GThemedIcon";
     static objectType = "gobject";
@@ -207,13 +213,25 @@ export class ThemedIcon extends GObject.GObject {
         ], { type: "string" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gio/threaded-resolver.js

@@ -2,6 +2,7 @@ import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import { Resolver } from "./resolver.js";
 /**
  * #GThreadedResolver is an implementation of #GResolver which calls the libc
@@ -9,6 +10,10 @@ import { Resolver } from "./resolver.js";
  */
 const SIGNAL_META = {
     reload: { params: [], returnType: { type: "undefined" } },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class ThreadedResolver extends Resolver {
     static glibTypeName = "GThreadedResolver";
@@ -44,6 +49,9 @@ export class ThreadedResolver extends Resolver {
                 if (t?.type === "gobject" && callbackArgs[i] != null) {
                     return getNativeObject(callbackArgs[i]);
                 }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
                 return callbackArgs[i];
             });
             const result = handler(self, ...wrapped);

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

@@ -2,6 +2,7 @@ import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import { SocketService } from "./socket-service.js";
 /**
  * A `GThreadedSocketService` is a simple subclass of {@link Gio.SocketService}
@@ -43,6 +44,10 @@ const SIGNAL_META = {
         ],
         returnType: { type: "undefined" },
     },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class ThreadedSocketService extends SocketService {
     static glibTypeName = "GThreadedSocketService";
@@ -84,6 +89,9 @@ export class ThreadedSocketService extends SocketService {
                 if (t?.type === "gobject" && callbackArgs[i] != null) {
                     return getNativeObject(callbackArgs[i]);
                 }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
                 return callbackArgs[i];
             });
             const result = handler(self, ...wrapped);

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

@@ -2,13 +2,6 @@ import { TlsCertificateFlags } from "./enums.js";
 import { SocketConnectable } from "./socket-connectable.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
-/**
- * A certificate used for TLS authentication and encryption.
- * This can represent either a certificate only (eg, the certificate
- * received by a client from a server), or the combination of
- * a certificate and a private key (which is needed when acting as a
- * {@link Gio.TlsServerConnection}).
- */
 export declare class TlsCertificate extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

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

@@ -12,6 +12,12 @@ import * as GObject from "../gobject/index.js";
  * a certificate and a private key (which is needed when acting as a
  * {@link Gio.TlsServerConnection}).
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class TlsCertificate extends GObject.GObject {
     static glibTypeName = "GTlsCertificate";
     static objectType = "gobject";
@@ -521,13 +527,25 @@ export class TlsCertificate extends GObject.GObject {
         ], { type: "int", size: 32, unsigned: false });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [

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

@@ -2,6 +2,7 @@ import { call } from "../../batch.js";
 import { NativeError } from "../../native/error.js";
 import { getNativeObject } from "../../native/object.js";
 import { registerNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import { IOStream } from "./iostream.js";
 /**
  * `GTlsConnection` is the base TLS connection class type, which wraps
@@ -20,6 +21,10 @@ const SIGNAL_META = {
         ],
         returnType: { type: "boolean" },
     },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class TlsConnection extends IOStream {
     static glibTypeName = "GTlsConnection";
@@ -569,6 +574,9 @@ export class TlsConnection extends IOStream {
                 if (t?.type === "gobject" && callbackArgs[i] != null) {
                     return getNativeObject(callbackArgs[i]);
                 }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
                 return callbackArgs[i];
             });
             const result = handler(self, ...wrapped);

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

@@ -6,17 +6,6 @@ import { TlsCertificate } from "./tls-certificate.js";
 import { TlsInteraction } from "./tls-interaction.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
-/**
- * `GTlsDatabase` is used to look up certificates and other information
- * from a certificate or key store. It is an abstract base class which
- * TLS library specific subtypes override.
- *
- * A `GTlsDatabase` may be accessed from multiple threads by the TLS backend.
- * All implementations are required to be fully thread-safe.
- *
- * Most common client applications will not directly interact with
- * `GTlsDatabase`. It is used internally by {@link Gio.TlsConnection}.
- */
 export declare class TlsDatabase extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

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

@@ -14,6 +14,12 @@ import * as GObject from "../gobject/index.js";
  * Most common client applications will not directly interact with
  * `GTlsDatabase`. It is used internally by {@link Gio.TlsConnection}.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class TlsDatabase extends GObject.GObject {
     static glibTypeName = "GTlsDatabase";
     static objectType = "gobject";
@@ -505,13 +511,25 @@ export class TlsDatabase extends GObject.GObject {
         return _result;
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [

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

@@ -4,28 +4,6 @@ import { Cancellable } from "./cancellable.js";
 import { TlsConnection } from "./tls-connection.js";
 import { TlsPassword } from "./tls-password.js";
 import * as GObject from "../gobject/index.js";
-/**
- * `GTlsInteraction` provides a mechanism for the TLS connection and database
- * code to interact with the user. It can be used to ask the user for passwords.
- *
- * To use a `GTlsInteraction` with a TLS connection use
- * {@link Gio.TlsConnection.set_interaction}.
- *
- * Callers should instantiate a derived class that implements the various
- * interaction methods to show the required dialogs.
- *
- * Callers should use the 'invoke' functions like
- * {@link Gio.TlsInteraction.invoke_ask_password} to run interaction methods.
- * These functions make sure that the interaction is invoked in the main loop
- * and not in the current thread, if the current thread is not running the
- * main loop.
- *
- * Derived classes can choose to implement whichever interactions methods they’d
- * like to support by overriding those virtual methods in their class
- * initialization function. Any interactions not implemented will return
- * `G_TLS_INTERACTION_UNHANDLED`. If a derived class implements an async method,
- * it must also implement the corresponding finish method.
- */
 export declare class TlsInteraction extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

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

@@ -26,6 +26,12 @@ import * as GObject from "../gobject/index.js";
  * `G_TLS_INTERACTION_UNHANDLED`. If a derived class implements an async method,
  * it must also implement the corresponding finish method.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class TlsInteraction extends GObject.GObject {
     static glibTypeName = "GTlsInteraction";
     static objectType = "gobject";
@@ -358,13 +364,25 @@ export class TlsInteraction extends GObject.GObject {
         return _result;
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [

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

@@ -1,10 +1,6 @@
 import { Ref } from "@gtkx/native";
 import { TlsPasswordFlags } from "./enums.js";
 import * as GObject from "../gobject/index.js";
-/**
- * An abstract interface representing a password used in TLS. Often used in
- * user interaction such as unlocking a key storage token.
- */
 export declare class TlsPassword extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";